.

qwen/nodejs/node_modules/sequelize/lib/errors/aggregate-error.js

@@ -0,0 +1,48 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => aggregate_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class AggregateError extends import_base_error.default {
+  constructor(errors) {
+    super();
+    __publicField(this, "errors");
+    this.errors = errors;
+    this.name = "AggregateError";
+  }
+  toString() {
+    const message = `AggregateError of:
+${this.errors.map((error) => error === this ? "[Circular AggregateError]" : error instanceof AggregateError ? String(error).replace(/\n$/, "").replace(/^/gm, "  ") : String(error).replace(/^/gm, "    ").substring(2)).join("\n")}
+`;
+    return message;
+  }
+}
+var aggregate_error_default = AggregateError;
+//# sourceMappingURL=aggregate-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/aggregate-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/aggregate-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * A wrapper for multiple Errors\n *\n * @param errors The aggregated errors that occurred\n */\nclass AggregateError extends BaseError {\n  /** the aggregated errors that occurred */\n  readonly errors: Array<AggregateError | Error>;\n\n  constructor(errors: Array<AggregateError | Error>) {\n    super();\n    this.errors = errors;\n    this.name = 'AggregateError';\n  }\n\n  toString(): string {\n    const message = `AggregateError of:\\n${this.errors\n      .map((error: Error | AggregateError) =>\n        error === this\n          ? '[Circular AggregateError]'\n          : error instanceof AggregateError\n            ? String(error).replace(/\\n$/, '').replace(/^/gm, '  ')\n            : String(error).replace(/^/gm, '    ').substring(2)\n      )\n      .join('\\n')}\\n`;\n    return message;\n  }\n}\n\nexport default AggregateError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAOtB,6BAA6B,0BAAU;AAAA,EAIrC,YAAY,QAAuC;AACjD;AAHO;AAIP,SAAK,SAAS;AACd,SAAK,OAAO;AAAA;AAAA,EAGd,WAAmB;AACjB,UAAM,UAAU;AAAA,EAAuB,KAAK,OACzC,IAAI,CAAC,UACJ,UAAU,OACN,8BACA,iBAAiB,iBACf,OAAO,OAAO,QAAQ,OAAO,IAAI,QAAQ,OAAO,QAChD,OAAO,OAAO,QAAQ,OAAO,QAAQ,UAAU,IAEtD,KAAK;AAAA;AACR,WAAO;AAAA;AAAA;AAIX,IAAO,0BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/association-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => association_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class AssociationError extends import_base_error.default {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeAssociationError";
+  }
+}
+var association_error_default = AssociationError;
+//# sourceMappingURL=association-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/association-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/association-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * Thrown when an association is improperly constructed (see message for details)\n */\nclass AssociationError extends BaseError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'SequelizeAssociationError';\n  }\n}\n\nexport default AssociationError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,+BAA+B,0BAAU;AAAA,EACvC,YAAY,SAAiB;AAC3B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,4BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/base-error.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+__export(exports, {
+  default: () => base_error_default
+});
+class BaseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeBaseError";
+  }
+}
+var base_error_default = BaseError;
+//# sourceMappingURL=base-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/base-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/base-error.ts"],
+  "sourcesContent": ["export interface ErrorOptions {\n  stack?: string;\n}\n\nexport interface CommonErrorProperties {\n  /** The database specific error which triggered this one */\n  readonly parent: Error;\n\n  /** The database specific error which triggered this one */\n  readonly original: Error;\n\n  /** The SQL that triggered the error */\n  readonly sql: string;\n}\n\n/**\n * The Base Error all Sequelize Errors inherit from.\n *\n * Sequelize provides a host of custom error classes, to allow you to do easier debugging. All of these errors are exposed on the sequelize object and the sequelize constructor.\n * All sequelize errors inherit from the base JS error object.\n *\n * This means that errors can be accessed using `Sequelize.ValidationError`\n */\nabstract class BaseError extends Error {\n  constructor(message?: string) {\n    super(message);\n    this.name = 'SequelizeBaseError';\n  }\n}\n\nexport default BaseError;\n"],
+  "mappings": ";;;;;;;AAAA;AAAA;AAAA;AAuBA,wBAAiC,MAAM;AAAA,EACrC,YAAY,SAAkB;AAC5B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,qBAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/bulk-record-error.js

@@ -0,0 +1,44 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => bulk_record_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class BulkRecordError extends import_base_error.default {
+  constructor(error, record) {
+    super(error.message);
+    __publicField(this, "errors");
+    __publicField(this, "record");
+    this.name = "SequelizeBulkRecordError";
+    this.errors = error;
+    this.record = record;
+  }
+}
+var bulk_record_error_default = BulkRecordError;
+//# sourceMappingURL=bulk-record-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/bulk-record-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/bulk-record-error.ts"],
+  "sourcesContent": ["import type { Model } from '..';\nimport BaseError from './base-error';\n\n/**\n * Thrown when bulk operation fails, it represent per record level error.\n * Used with AggregateError\n *\n * @param error Error for a given record/instance\n * @param record DAO instance that error belongs to\n */\nclass BulkRecordError extends BaseError {\n  errors: Error;\n  record: Model;\n\n  constructor(error: Error, record: Model) {\n    super(error.message);\n    this.name = 'SequelizeBulkRecordError';\n    this.errors = error;\n    this.record = record;\n  }\n}\n\nexport default BulkRecordError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AACA,wBAAsB;AAStB,8BAA8B,0BAAU;AAAA,EAItC,YAAY,OAAc,QAAe;AACvC,UAAM,MAAM;AAJd;AACA;AAIE,SAAK,OAAO;AACZ,SAAK,SAAS;AACd,SAAK,SAAS;AAAA;AAAA;AAIlB,IAAO,4BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection-error.js

@@ -0,0 +1,44 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => connection_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class ConnectionError extends import_base_error.default {
+  constructor(parent) {
+    super(parent ? parent.message : "");
+    __publicField(this, "parent");
+    __publicField(this, "original");
+    this.name = "SequelizeConnectionError";
+    this.parent = parent;
+    this.original = parent;
+  }
+}
+var connection_error_default = ConnectionError;
+//# sourceMappingURL=connection-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/connection-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * A base class for all connection related errors.\n */\nclass ConnectionError extends BaseError {\n  /** The connection specific error which triggered this one */\n  parent: Error;\n  original: Error;\n\n  constructor(parent: Error) {\n    super(parent ? parent.message : '');\n    this.name = 'SequelizeConnectionError';\n    this.parent = parent;\n    this.original = parent;\n  }\n}\n\nexport default ConnectionError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,8BAA8B,0BAAU;AAAA,EAKtC,YAAY,QAAe;AACzB,UAAM,SAAS,OAAO,UAAU;AAJlC;AACA;AAIE,SAAK,OAAO;AACZ,SAAK,SAAS;AACd,SAAK,WAAW;AAAA;AAAA;AAIpB,IAAO,2BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/access-denied-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => access_denied_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class AccessDeniedError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeAccessDeniedError";
+  }
+}
+var access_denied_error_default = AccessDeniedError;
+//# sourceMappingURL=access-denied-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/access-denied-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/access-denied-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when a connection to a database is refused due to insufficient privileges\n */\nclass AccessDeniedError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeAccessDeniedError';\n  }\n}\n\nexport default AccessDeniedError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,gCAAgC,gCAAgB;AAAA,EAC9C,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,8BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/connection-acquire-timeout-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => connection_acquire_timeout_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class ConnectionAcquireTimeoutError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeConnectionAcquireTimeoutError";
+  }
+}
+var connection_acquire_timeout_error_default = ConnectionAcquireTimeoutError;
+//# sourceMappingURL=connection-acquire-timeout-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/connection-acquire-timeout-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/connection-acquire-timeout-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when connection is not acquired due to timeout\n */\nclass ConnectionAcquireTimeoutError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeConnectionAcquireTimeoutError';\n  }\n}\n\nexport default ConnectionAcquireTimeoutError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,4CAA4C,gCAAgB;AAAA,EAC1D,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,2CAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/connection-refused-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => connection_refused_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class ConnectionRefusedError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeConnectionRefusedError";
+  }
+}
+var connection_refused_error_default = ConnectionRefusedError;
+//# sourceMappingURL=connection-refused-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/connection-refused-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/connection-refused-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when a connection to a database is refused\n */\nclass ConnectionRefusedError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeConnectionRefusedError';\n  }\n}\n\nexport default ConnectionRefusedError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,qCAAqC,gCAAgB;AAAA,EACnD,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,mCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/connection-timed-out-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => connection_timed_out_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class ConnectionTimedOutError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeConnectionTimedOutError";
+  }
+}
+var connection_timed_out_error_default = ConnectionTimedOutError;
+//# sourceMappingURL=connection-timed-out-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/connection-timed-out-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/connection-timed-out-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when a connection to a database times out\n */\nclass ConnectionTimedOutError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeConnectionTimedOutError';\n  }\n}\n\nexport default ConnectionTimedOutError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,sCAAsC,gCAAgB;AAAA,EACpD,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,qCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/host-not-found-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => host_not_found_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class HostNotFoundError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeHostNotFoundError";
+  }
+}
+var host_not_found_error_default = HostNotFoundError;
+//# sourceMappingURL=host-not-found-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/host-not-found-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/host-not-found-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when a connection to a database has a hostname that was not found\n */\nclass HostNotFoundError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeHostNotFoundError';\n  }\n}\n\nexport default HostNotFoundError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,gCAAgC,gCAAgB;AAAA,EAC9C,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,+BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/host-not-reachable-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => host_not_reachable_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class HostNotReachableError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeHostNotReachableError";
+  }
+}
+var host_not_reachable_error_default = HostNotReachableError;
+//# sourceMappingURL=host-not-reachable-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/host-not-reachable-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/host-not-reachable-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when a connection to a database has a hostname that was not reachable\n */\nclass HostNotReachableError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeHostNotReachableError';\n  }\n}\n\nexport default HostNotReachableError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,oCAAoC,gCAAgB;AAAA,EAClD,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,mCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/connection/invalid-connection-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => invalid_connection_error_default
+});
+var import_connection_error = __toModule(require("../connection-error"));
+class InvalidConnectionError extends import_connection_error.default {
+  constructor(parent) {
+    super(parent);
+    this.name = "SequelizeInvalidConnectionError";
+  }
+}
+var invalid_connection_error_default = InvalidConnectionError;
+//# sourceMappingURL=invalid-connection-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/connection/invalid-connection-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/connection/invalid-connection-error.ts"],
+  "sourcesContent": ["import ConnectionError from '../connection-error';\n\n/**\n * Thrown when a connection to a database has invalid values for any of the connection parameters\n */\nclass InvalidConnectionError extends ConnectionError {\n  constructor(parent: Error) {\n    super(parent);\n    this.name = 'SequelizeInvalidConnectionError';\n  }\n}\n\nexport default InvalidConnectionError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,8BAA4B;AAK5B,qCAAqC,gCAAgB;AAAA,EACnD,YAAY,QAAe;AACzB,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,mCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/database-error.js

@@ -0,0 +1,52 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => database_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class DatabaseError extends import_base_error.default {
+  constructor(parent, options = {}) {
+    super(parent.message);
+    __publicField(this, "parent");
+    __publicField(this, "original");
+    __publicField(this, "sql");
+    __publicField(this, "parameters");
+    var _a;
+    this.name = "SequelizeDatabaseError";
+    this.parent = parent;
+    this.original = parent;
+    this.sql = parent.sql;
+    this.parameters = (_a = parent.parameters) != null ? _a : {};
+    if (options.stack) {
+      this.stack = options.stack;
+    }
+  }
+}
+var database_error_default = DatabaseError;
+//# sourceMappingURL=database-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/database-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/database-error.ts"],
+  "sourcesContent": ["import BaseError, { CommonErrorProperties, ErrorOptions } from './base-error';\n\nexport interface DatabaseErrorParent\n  extends Error,\n    Pick<CommonErrorProperties, 'sql'> {\n  /** The parameters for the sql that triggered the error */\n  readonly parameters?: object;\n}\n\nexport interface DatabaseErrorSubclassOptions extends ErrorOptions {\n  parent?: DatabaseErrorParent;\n  message?: string;\n}\n\n/**\n * A base class for all database related errors.\n */\nclass DatabaseError\n  extends BaseError\n  implements DatabaseErrorParent, CommonErrorProperties\n{\n  parent: Error;\n  original: Error;\n  sql: string;\n  parameters: object;\n\n  /**\n   * @param parent The database specific error which triggered this one\n   * @param options\n   */\n  constructor(parent: DatabaseErrorParent, options: ErrorOptions = {}) {\n    super(parent.message);\n    this.name = 'SequelizeDatabaseError';\n\n    this.parent = parent;\n    this.original = parent;\n\n    this.sql = parent.sql;\n    this.parameters = parent.parameters ?? {};\n\n    if (options.stack) {\n      this.stack = options.stack;\n    }\n  }\n}\n\nexport default DatabaseError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAA+D;AAiB/D,4BACU,0BAEV;AAAA,EAUE,YAAY,QAA6B,UAAwB,IAAI;AACnE,UAAM,OAAO;AAVf;AACA;AACA;AACA;AAxBF;AAgCI,SAAK,OAAO;AAEZ,SAAK,SAAS;AACd,SAAK,WAAW;AAEhB,SAAK,MAAM,OAAO;AAClB,SAAK,aAAa,aAAO,eAAP,YAAqB;AAEvC,QAAI,QAAQ,OAAO;AACjB,WAAK,QAAQ,QAAQ;AAAA;AAAA;AAAA;AAK3B,IAAO,yBAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/database/exclusion-constraint-error.js

@@ -0,0 +1,49 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => exclusion_constraint_error_default
+});
+var import_database_error = __toModule(require("../database-error"));
+class ExclusionConstraintError extends import_database_error.default {
+  constructor(options) {
+    options = options || {};
+    options.parent = options.parent || { sql: "", name: "", message: "" };
+    super(options.parent, { stack: options.stack });
+    __publicField(this, "constraint");
+    __publicField(this, "fields");
+    __publicField(this, "table");
+    this.name = "SequelizeExclusionConstraintError";
+    this.message = options.message || options.parent.message || "";
+    this.constraint = options.constraint;
+    this.fields = options.fields;
+    this.table = options.table;
+  }
+}
+var exclusion_constraint_error_default = ExclusionConstraintError;
+//# sourceMappingURL=exclusion-constraint-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/database/exclusion-constraint-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/database/exclusion-constraint-error.ts"],
+  "sourcesContent": ["import DatabaseError, { DatabaseErrorSubclassOptions } from '../database-error';\n\ninterface ExclusionConstraintErrorOptions {\n  constraint?: string;\n  fields?: Record<string, string | number>;\n  table?: string;\n}\n\n/**\n * Thrown when an exclusion constraint is violated in the database\n */\nclass ExclusionConstraintError extends DatabaseError implements ExclusionConstraintErrorOptions {\n  constraint: string | undefined;\n  fields: Record<string, string | number> | undefined;\n  table: string | undefined;\n\n  constructor(\n    options: DatabaseErrorSubclassOptions & ExclusionConstraintErrorOptions\n  ) {\n    options = options || {};\n    options.parent = options.parent || { sql: '', name: '', message: '' };\n\n    super(options.parent, { stack: options.stack });\n    this.name = 'SequelizeExclusionConstraintError';\n\n    this.message = options.message || options.parent.message || '';\n    this.constraint = options.constraint;\n    this.fields = options.fields;\n    this.table = options.table;\n  }\n}\n\nexport default ExclusionConstraintError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,4BAA4D;AAW5D,uCAAuC,8BAAyD;AAAA,EAK9F,YACE,SACA;AACA,cAAU,WAAW;AACrB,YAAQ,SAAS,QAAQ,UAAU,EAAE,KAAK,IAAI,MAAM,IAAI,SAAS;AAEjE,UAAM,QAAQ,QAAQ,EAAE,OAAO,QAAQ;AAVzC;AACA;AACA;AASE,SAAK,OAAO;AAEZ,SAAK,UAAU,QAAQ,WAAW,QAAQ,OAAO,WAAW;AAC5D,SAAK,aAAa,QAAQ;AAC1B,SAAK,SAAS,QAAQ;AACtB,SAAK,QAAQ,QAAQ;AAAA;AAAA;AAIzB,IAAO,qCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/database/foreign-key-constraint-error.js

@@ -0,0 +1,59 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  RelationshipType: () => RelationshipType,
+  default: () => foreign_key_constraint_error_default
+});
+var import_database_error = __toModule(require("../database-error"));
+var RelationshipType = /* @__PURE__ */ ((RelationshipType2) => {
+  RelationshipType2["parent"] = "parent";
+  RelationshipType2["child"] = "child";
+  return RelationshipType2;
+})(RelationshipType || {});
+class ForeignKeyConstraintError extends import_database_error.default {
+  constructor(options) {
+    options = options || {};
+    options.parent = options.parent || { sql: "", name: "", message: "" };
+    super(options.parent, { stack: options.stack });
+    __publicField(this, "table");
+    __publicField(this, "fields");
+    __publicField(this, "value");
+    __publicField(this, "index");
+    __publicField(this, "reltype");
+    this.name = "SequelizeForeignKeyConstraintError";
+    this.message = options.message || options.parent.message || "Database Error";
+    this.fields = options.fields;
+    this.table = options.table;
+    this.value = options.value;
+    this.index = options.index;
+    this.reltype = options.reltype;
+  }
+}
+var foreign_key_constraint_error_default = ForeignKeyConstraintError;
+//# sourceMappingURL=foreign-key-constraint-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/database/foreign-key-constraint-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/database/foreign-key-constraint-error.ts"],
+  "sourcesContent": ["import DatabaseError, { DatabaseErrorSubclassOptions } from '../database-error';\n\nexport enum RelationshipType {\n  parent = 'parent',\n  child = 'child',\n}\n\ninterface ForeignKeyConstraintErrorOptions {\n  table?: string;\n  fields?: { [field: string]: string };\n  value?: unknown;\n  index?: string;\n  reltype?: RelationshipType;\n}\n\n/**\n * Thrown when a foreign key constraint is violated in the database\n */\nclass ForeignKeyConstraintError extends DatabaseError {\n  table: string | undefined;\n  fields: { [field: string]: string } | undefined;\n  value: unknown;\n  index: string | undefined;\n  reltype: RelationshipType | undefined;\n\n  constructor(\n    options: ForeignKeyConstraintErrorOptions & DatabaseErrorSubclassOptions\n  ) {\n    options = options || {};\n    options.parent = options.parent || { sql: '', name: '', message: '' };\n\n    super(options.parent, { stack: options.stack });\n    this.name = 'SequelizeForeignKeyConstraintError';\n\n    this.message =\n      options.message || options.parent.message || 'Database Error';\n    this.fields = options.fields;\n    this.table = options.table;\n    this.value = options.value;\n    this.index = options.index;\n    this.reltype = options.reltype;\n  }\n}\n\nexport default ForeignKeyConstraintError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA,4BAA4D;AAErD,IAAK,mBAAL,kBAAK,sBAAL;AACL,gCAAS;AACT,+BAAQ;AAFE;AAAA;AAgBZ,wCAAwC,8BAAc;AAAA,EAOpD,YACE,SACA;AACA,cAAU,WAAW;AACrB,YAAQ,SAAS,QAAQ,UAAU,EAAE,KAAK,IAAI,MAAM,IAAI,SAAS;AAEjE,UAAM,QAAQ,QAAQ,EAAE,OAAO,QAAQ;AAZzC;AACA;AACA;AACA;AACA;AASE,SAAK,OAAO;AAEZ,SAAK,UACH,QAAQ,WAAW,QAAQ,OAAO,WAAW;AAC/C,SAAK,SAAS,QAAQ;AACtB,SAAK,QAAQ,QAAQ;AACrB,SAAK,QAAQ,QAAQ;AACrB,SAAK,QAAQ,QAAQ;AACrB,SAAK,UAAU,QAAQ;AAAA;AAAA;AAI3B,IAAO,uCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/database/timeout-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => timeout_error_default
+});
+var import_database_error = __toModule(require("../database-error"));
+class TimeoutError extends import_database_error.default {
+  constructor(parent, options = {}) {
+    super(parent, options);
+    this.name = "SequelizeTimeoutError";
+  }
+}
+var timeout_error_default = TimeoutError;
+//# sourceMappingURL=timeout-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/database/timeout-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/database/timeout-error.ts"],
+  "sourcesContent": ["import { ErrorOptions } from '../base-error';\nimport DatabaseError, { DatabaseErrorParent } from '../database-error';\n\n/**\n * Thrown when a database query times out because of a deadlock\n */\nclass TimeoutError extends DatabaseError {\n  constructor(parent: DatabaseErrorParent, options: ErrorOptions = {}) {\n    super(parent, options);\n    this.name = 'SequelizeTimeoutError';\n  }\n}\n\nexport default TimeoutError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AACA,4BAAmD;AAKnD,2BAA2B,8BAAc;AAAA,EACvC,YAAY,QAA6B,UAAwB,IAAI;AACnE,UAAM,QAAQ;AACd,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,wBAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/database/unknown-constraint-error.js

@@ -0,0 +1,49 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => unknown_constraint_error_default
+});
+var import_database_error = __toModule(require("../database-error"));
+class UnknownConstraintError extends import_database_error.default {
+  constructor(options) {
+    options = options || {};
+    options.parent = options.parent || { sql: "", name: "", message: "" };
+    super(options.parent, { stack: options.stack });
+    __publicField(this, "constraint");
+    __publicField(this, "fields");
+    __publicField(this, "table");
+    this.name = "SequelizeUnknownConstraintError";
+    this.message = options.message || "The specified constraint does not exist";
+    this.constraint = options.constraint;
+    this.fields = options.fields;
+    this.table = options.table;
+  }
+}
+var unknown_constraint_error_default = UnknownConstraintError;
+//# sourceMappingURL=unknown-constraint-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/database/unknown-constraint-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/database/unknown-constraint-error.ts"],
+  "sourcesContent": ["import DatabaseError, { DatabaseErrorSubclassOptions } from '../database-error';\n\ninterface UnknownConstraintErrorOptions {\n  constraint?: string;\n  fields?: Record<string, string | number>;\n  table?: string;\n}\n\n/**\n * Thrown when constraint name is not found in the database\n */\nclass UnknownConstraintError extends DatabaseError implements UnknownConstraintErrorOptions {\n  constraint: string | undefined;\n  fields: Record<string, string | number> | undefined;\n  table: string | undefined;\n\n  constructor(\n    options: UnknownConstraintErrorOptions & DatabaseErrorSubclassOptions\n  ) {\n    options = options || {};\n    options.parent = options.parent || { sql: '', name: '', message: '' };\n\n    super(options.parent, { stack: options.stack });\n    this.name = 'SequelizeUnknownConstraintError';\n\n    this.message = options.message || 'The specified constraint does not exist';\n    this.constraint = options.constraint;\n    this.fields = options.fields;\n    this.table = options.table;\n  }\n}\n\nexport default UnknownConstraintError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,4BAA4D;AAW5D,qCAAqC,8BAAuD;AAAA,EAK1F,YACE,SACA;AACA,cAAU,WAAW;AACrB,YAAQ,SAAS,QAAQ,UAAU,EAAE,KAAK,IAAI,MAAM,IAAI,SAAS;AAEjE,UAAM,QAAQ,QAAQ,EAAE,OAAO,QAAQ;AAVzC;AACA;AACA;AASE,SAAK,OAAO;AAEZ,SAAK,UAAU,QAAQ,WAAW;AAClC,SAAK,aAAa,QAAQ;AAC1B,SAAK,SAAS,QAAQ;AACtB,SAAK,QAAQ,QAAQ;AAAA;AAAA;AAIzB,IAAO,mCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/eager-loading-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => eager_loading_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class EagerLoadingError extends import_base_error.default {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeEagerLoadingError";
+  }
+}
+var eager_loading_error_default = EagerLoadingError;
+//# sourceMappingURL=eager-loading-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/eager-loading-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/eager-loading-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * Thrown when an include statement is improperly constructed (see message for details)\n */\nclass EagerLoadingError extends BaseError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'SequelizeEagerLoadingError';\n  }\n}\n\nexport default EagerLoadingError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,gCAAgC,0BAAU;AAAA,EACxC,YAAY,SAAiB;AAC3B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,8BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/empty-result-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => empty_result_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class EmptyResultError extends import_base_error.default {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeEmptyResultError";
+  }
+}
+var empty_result_error_default = EmptyResultError;
+//# sourceMappingURL=empty-result-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/empty-result-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/empty-result-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * Thrown when a record was not found, Usually used with rejectOnEmpty mode (see message for details)\n */\nclass EmptyResultError extends BaseError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'SequelizeEmptyResultError';\n  }\n}\n\nexport default EmptyResultError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,+BAA+B,0BAAU;AAAA,EACvC,YAAY,SAAiB;AAC3B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,6BAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/index.js

@@ -0,0 +1,81 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  AccessDeniedError: () => import_access_denied_error.default,
+  AggregateError: () => import_aggregate_error.default,
+  AssociationError: () => import_association_error.default,
+  AsyncQueueError: () => import_async_queue.AsyncQueueError,
+  BaseError: () => import_base_error.default,
+  BulkRecordError: () => import_bulk_record_error.default,
+  ConnectionAcquireTimeoutError: () => import_connection_acquire_timeout_error.default,
+  ConnectionError: () => import_connection_error.default,
+  ConnectionRefusedError: () => import_connection_refused_error.default,
+  ConnectionTimedOutError: () => import_connection_timed_out_error.default,
+  DatabaseError: () => import_database_error.default,
+  EagerLoadingError: () => import_eager_loading_error.default,
+  EmptyResultError: () => import_empty_result_error.default,
+  ExclusionConstraintError: () => import_exclusion_constraint_error.default,
+  ForeignKeyConstraintError: () => import_foreign_key_constraint_error.default,
+  HostNotFoundError: () => import_host_not_found_error.default,
+  HostNotReachableError: () => import_host_not_reachable_error.default,
+  InstanceError: () => import_instance_error.default,
+  InvalidConnectionError: () => import_invalid_connection_error.default,
+  OptimisticLockError: () => import_optimistic_lock_error.default,
+  QueryError: () => import_query_error.default,
+  SequelizeScopeError: () => import_sequelize_scope_error.default,
+  TimeoutError: () => import_timeout_error.default,
+  UniqueConstraintError: () => import_unique_constraint_error.default,
+  UnknownConstraintError: () => import_unknown_constraint_error.default,
+  ValidationError: () => import_validation_error.default,
+  ValidationErrorItem: () => import_validation_error.ValidationErrorItem,
+  ValidationErrorItemOrigin: () => import_validation_error.ValidationErrorItemOrigin,
+  ValidationErrorItemType: () => import_validation_error.ValidationErrorItemType
+});
+var import_base_error = __toModule(require("./base-error"));
+var import_database_error = __toModule(require("./database-error"));
+var import_aggregate_error = __toModule(require("./aggregate-error"));
+var import_association_error = __toModule(require("./association-error"));
+var import_bulk_record_error = __toModule(require("./bulk-record-error"));
+var import_connection_error = __toModule(require("./connection-error"));
+var import_eager_loading_error = __toModule(require("./eager-loading-error"));
+var import_empty_result_error = __toModule(require("./empty-result-error"));
+var import_instance_error = __toModule(require("./instance-error"));
+var import_optimistic_lock_error = __toModule(require("./optimistic-lock-error"));
+var import_query_error = __toModule(require("./query-error"));
+var import_sequelize_scope_error = __toModule(require("./sequelize-scope-error"));
+var import_validation_error = __toModule(require("./validation-error"));
+var import_access_denied_error = __toModule(require("./connection/access-denied-error"));
+var import_connection_acquire_timeout_error = __toModule(require("./connection/connection-acquire-timeout-error"));
+var import_connection_refused_error = __toModule(require("./connection/connection-refused-error"));
+var import_connection_timed_out_error = __toModule(require("./connection/connection-timed-out-error"));
+var import_host_not_found_error = __toModule(require("./connection/host-not-found-error"));
+var import_host_not_reachable_error = __toModule(require("./connection/host-not-reachable-error"));
+var import_invalid_connection_error = __toModule(require("./connection/invalid-connection-error"));
+var import_exclusion_constraint_error = __toModule(require("./database/exclusion-constraint-error"));
+var import_foreign_key_constraint_error = __toModule(require("./database/foreign-key-constraint-error"));
+var import_timeout_error = __toModule(require("./database/timeout-error"));
+var import_unknown_constraint_error = __toModule(require("./database/unknown-constraint-error"));
+var import_unique_constraint_error = __toModule(require("./validation/unique-constraint-error"));
+var import_async_queue = __toModule(require("../dialects/mssql/async-queue"));
+//# sourceMappingURL=index.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/index.ts"],
+  "sourcesContent": ["export { default as BaseError } from './base-error';\n\nexport { default as DatabaseError } from './database-error';\nexport { default as AggregateError } from './aggregate-error';\nexport { default as AssociationError } from './association-error';\nexport { default as BulkRecordError } from './bulk-record-error';\nexport { default as ConnectionError } from './connection-error';\nexport { default as EagerLoadingError } from './eager-loading-error';\nexport { default as EmptyResultError } from './empty-result-error';\nexport { default as InstanceError } from './instance-error';\nexport { default as OptimisticLockError } from './optimistic-lock-error';\nexport { default as QueryError } from './query-error';\nexport { default as SequelizeScopeError } from './sequelize-scope-error';\nexport {\n  default as ValidationError,\n  ValidationErrorItem,\n  ValidationErrorItemOrigin,\n  ValidationErrorItemType\n} from './validation-error';\n\nexport { default as AccessDeniedError } from './connection/access-denied-error';\nexport { default as ConnectionAcquireTimeoutError } from './connection/connection-acquire-timeout-error';\nexport { default as ConnectionRefusedError } from './connection/connection-refused-error';\nexport { default as ConnectionTimedOutError } from './connection/connection-timed-out-error';\nexport { default as HostNotFoundError } from './connection/host-not-found-error';\nexport { default as HostNotReachableError } from './connection/host-not-reachable-error';\nexport { default as InvalidConnectionError } from './connection/invalid-connection-error';\n\nexport { default as ExclusionConstraintError } from './database/exclusion-constraint-error';\nexport { default as ForeignKeyConstraintError } from './database/foreign-key-constraint-error';\nexport { default as TimeoutError } from './database/timeout-error';\nexport { default as UnknownConstraintError } from './database/unknown-constraint-error';\n\nexport { default as UniqueConstraintError } from './validation/unique-constraint-error';\n\nexport { AsyncQueueError } from '../dialects/mssql/async-queue';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAqC;AAErC,4BAAyC;AACzC,6BAA0C;AAC1C,+BAA4C;AAC5C,+BAA2C;AAC3C,8BAA2C;AAC3C,iCAA6C;AAC7C,gCAA4C;AAC5C,4BAAyC;AACzC,mCAA+C;AAC/C,yBAAsC;AACtC,mCAA+C;AAC/C,8BAKO;AAEP,iCAA6C;AAC7C,8CAAyD;AACzD,sCAAkD;AAClD,wCAAmD;AACnD,kCAA6C;AAC7C,sCAAiD;AACjD,sCAAkD;AAElD,wCAAoD;AACpD,0CAAqD;AACrD,2BAAwC;AACxC,sCAAkD;AAElD,qCAAiD;AAEjD,yBAAgC;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/instance-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => instance_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class InstanceError extends import_base_error.default {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeInstanceError";
+  }
+}
+var instance_error_default = InstanceError;
+//# sourceMappingURL=instance-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/instance-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/instance-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * Thrown when a some problem occurred with Instance methods (see message for details)\n */\nclass InstanceError extends BaseError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'SequelizeInstanceError';\n  }\n}\n\nexport default InstanceError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,4BAA4B,0BAAU;AAAA,EACpC,YAAY,SAAiB;AAC3B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,yBAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/optimistic-lock-error.js

@@ -0,0 +1,48 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => optimistic_lock_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class OptimisticLockError extends import_base_error.default {
+  constructor(options) {
+    options = options || {};
+    options.message = options.message || `Attempting to update a stale model instance: ${options.modelName}`;
+    super(options.message);
+    __publicField(this, "modelName");
+    __publicField(this, "values");
+    __publicField(this, "where");
+    this.name = "SequelizeOptimisticLockError";
+    this.modelName = options.modelName;
+    this.values = options.values;
+    this.where = options.where;
+  }
+}
+var optimistic_lock_error_default = OptimisticLockError;
+//# sourceMappingURL=optimistic-lock-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/optimistic-lock-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/optimistic-lock-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\ninterface OptimisticLockErrorOptions {\n  message?: string;\n\n  /** The name of the model on which the update was attempted */\n  modelName?: string;\n\n  /** The values of the attempted update */\n  values?: Record<string, unknown>;\n  where?: Record<string, unknown>;\n}\n\n/**\n * Thrown when attempting to update a stale model instance\n */\nclass OptimisticLockError extends BaseError {\n  modelName: string | undefined;\n  values: Record<string, unknown> | undefined;\n  where: Record<string, unknown> | undefined;\n\n  constructor(options: OptimisticLockErrorOptions) {\n    options = options || {};\n    options.message =\n      options.message ||\n      `Attempting to update a stale model instance: ${options.modelName}`;\n\n    super(options.message);\n    this.name = 'SequelizeOptimisticLockError';\n    this.modelName = options.modelName;\n    this.values = options.values;\n    this.where = options.where;\n  }\n}\n\nexport default OptimisticLockError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAgBtB,kCAAkC,0BAAU;AAAA,EAK1C,YAAY,SAAqC;AAC/C,cAAU,WAAW;AACrB,YAAQ,UACN,QAAQ,WACR,gDAAgD,QAAQ;AAE1D,UAAM,QAAQ;AAVhB;AACA;AACA;AASE,SAAK,OAAO;AACZ,SAAK,YAAY,QAAQ;AACzB,SAAK,SAAS,QAAQ;AACtB,SAAK,QAAQ,QAAQ;AAAA;AAAA;AAIzB,IAAO,gCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/query-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => query_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class QueryError extends import_base_error.default {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeQueryError";
+  }
+}
+var query_error_default = QueryError;
+//# sourceMappingURL=query-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/query-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/query-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * Thrown when a query is passed invalid options (see message for details)\n */\nclass QueryError extends BaseError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'SequelizeQueryError';\n  }\n}\n\nexport default QueryError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,yBAAyB,0BAAU;AAAA,EACjC,YAAY,SAAiB;AAC3B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,sBAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/sequelize-scope-error.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  default: () => sequelize_scope_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+class SequelizeScopeError extends import_base_error.default {
+  constructor(message) {
+    super(message);
+    this.name = "SequelizeScopeError";
+  }
+}
+var sequelize_scope_error_default = SequelizeScopeError;
+//# sourceMappingURL=sequelize-scope-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/sequelize-scope-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors/sequelize-scope-error.ts"],
+  "sourcesContent": ["import BaseError from './base-error';\n\n/**\n * Scope Error. Thrown when the sequelize cannot query the specified scope.\n */\nclass SequelizeScopeError extends BaseError {\n  constructor(message: string) {\n    super(message);\n    this.name = 'SequelizeScopeError';\n  }\n}\n\nexport default SequelizeScopeError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AAKtB,kCAAkC,0BAAU;AAAA,EAC1C,YAAY,SAAiB;AAC3B,UAAM;AACN,SAAK,OAAO;AAAA;AAAA;AAIhB,IAAO,gCAAQ;",
+  "names": []
+}

qwen/nodejs/node_modules/sequelize/lib/errors/validation-error.js

@@ -0,0 +1,131 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  ValidationErrorItem: () => ValidationErrorItem,
+  ValidationErrorItemOrigin: () => ValidationErrorItemOrigin,
+  ValidationErrorItemType: () => ValidationErrorItemType,
+  default: () => validation_error_default
+});
+var import_base_error = __toModule(require("./base-error"));
+var ValidationErrorItemType = /* @__PURE__ */ ((ValidationErrorItemType2) => {
+  ValidationErrorItemType2["notnull violation"] = "CORE";
+  ValidationErrorItemType2["string violation"] = "CORE";
+  ValidationErrorItemType2["unique violation"] = "DB";
+  ValidationErrorItemType2["validation error"] = "FUNCTION";
+  return ValidationErrorItemType2;
+})(ValidationErrorItemType || {});
+var ValidationErrorItemOrigin = /* @__PURE__ */ ((ValidationErrorItemOrigin2) => {
+  ValidationErrorItemOrigin2["CORE"] = "CORE";
+  ValidationErrorItemOrigin2["DB"] = "DB";
+  ValidationErrorItemOrigin2["FUNCTION"] = "FUNCTION";
+  return ValidationErrorItemOrigin2;
+})(ValidationErrorItemOrigin || {});
+class ValidationErrorItem {
+  constructor(message, type, path, value, instance, validatorKey, fnName, fnArgs) {
+    __publicField(this, "message");
+    __publicField(this, "type");
+    __publicField(this, "path");
+    __publicField(this, "value");
+    __publicField(this, "origin");
+    __publicField(this, "instance");
+    __publicField(this, "validatorKey");
+    __publicField(this, "validatorName");
+    __publicField(this, "validatorArgs");
+    this.message = message || "";
+    this.type = null;
+    this.path = path || null;
+    this.value = value !== void 0 ? value : null;
+    this.origin = null;
+    this.instance = instance || null;
+    this.validatorKey = validatorKey || null;
+    this.validatorName = fnName || null;
+    this.validatorArgs = fnArgs || [];
+    if (type) {
+      if (this.isValidationErrorItemOrigin(type)) {
+        this.origin = type;
+      } else {
+        const lowercaseType = this.normalizeString(type);
+        const realType = ValidationErrorItemType[lowercaseType];
+        if (realType && ValidationErrorItemOrigin[realType]) {
+          this.origin = realType;
+          this.type = type;
+        }
+      }
+    }
+  }
+  isValidationErrorItemOrigin(origin) {
+    return ValidationErrorItemOrigin[origin] !== void 0;
+  }
+  normalizeString(str) {
+    return str.toLowerCase().trim();
+  }
+  getValidatorKey(useTypeAsNS, NSSeparator) {
+    const useTANS = useTypeAsNS === void 0 || !!useTypeAsNS;
+    const NSSep = NSSeparator === void 0 ? "." : NSSeparator;
+    const type = this.origin;
+    const key = this.validatorKey || this.validatorName;
+    const useNS = useTANS && type && ValidationErrorItemOrigin[type];
+    if (useNS && (typeof NSSep !== "string" || !NSSep.length)) {
+      throw new Error("Invalid namespace separator given, must be a non-empty string");
+    }
+    if (!(typeof key === "string" && key.length)) {
+      return "";
+    }
+    return (useNS ? [this.origin, key].join(NSSep) : key).toLowerCase().trim();
+  }
+}
+__publicField(ValidationErrorItem, "TypeStringMap", ValidationErrorItemType);
+__publicField(ValidationErrorItem, "Origins", ValidationErrorItemOrigin);
+class ValidationError extends import_base_error.default {
+  constructor(message, errors, options = {}) {
+    super(message);
+    __publicField(this, "errors");
+    this.name = "SequelizeValidationError";
+    this.message = "Validation Error";
+    this.errors = errors || [];
+    if (message) {
+      this.message = message;
+    } else if (this.errors.length > 0 && this.errors[0].message) {
+      this.message = this.errors.map((err) => `${err.type || err.origin}: ${err.message}`).join(",\n");
+    }
+    if (options.stack) {
+      this.stack = options.stack;
+    }
+  }
+  get(path) {
+    return this.errors.reduce((reduced, error) => {
+      if (error.path === path) {
+        reduced.push(error);
+      }
+      return reduced;
+    }, []);
+  }
+}
+var validation_error_default = ValidationError;
+//# sourceMappingURL=validation-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/validation/unique-constraint-error.js

@@ -0,0 +1,53 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+__export(exports, {
+  default: () => unique_constraint_error_default
+});
+var import_validation_error = __toModule(require("../validation-error"));
+class UniqueConstraintError extends import_validation_error.default {
+  constructor(options) {
+    var _a, _b, _c;
+    options = options != null ? options : {};
+    options.parent = (_a = options.parent) != null ? _a : { sql: "", name: "", message: "" };
+    options.message = options.message || options.parent.message || "Validation Error";
+    options.errors = (_b = options.errors) != null ? _b : [];
+    super(options.message, options.errors, { stack: options.stack });
+    __publicField(this, "parent");
+    __publicField(this, "original");
+    __publicField(this, "fields");
+    __publicField(this, "sql");
+    this.name = "SequelizeUniqueConstraintError";
+    this.fields = (_c = options.fields) != null ? _c : {};
+    this.parent = options.parent;
+    this.original = options.parent;
+    this.sql = options.parent.sql;
+  }
+}
+var unique_constraint_error_default = UniqueConstraintError;
+//# sourceMappingURL=unique-constraint-error.js.map

qwen/nodejs/node_modules/sequelize/lib/errors/validation/unique-constraint-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors/validation/unique-constraint-error.ts"],
+  "sourcesContent": ["import { CommonErrorProperties, ErrorOptions } from '../base-error';\nimport ValidationError, { ValidationErrorItem } from '../validation-error';\n\ninterface UniqueConstraintErrorParent\n  extends Error,\n    Pick<CommonErrorProperties, 'sql'> {}\n\nexport interface UniqueConstraintErrorOptions extends ErrorOptions {\n  parent?: UniqueConstraintErrorParent;\n  original?: UniqueConstraintErrorParent;\n  errors?: ValidationErrorItem[];\n  fields?: Record<string, unknown>;\n  message?: string;\n}\n\n/**\n * Thrown when a unique constraint is violated in the database\n */\nclass UniqueConstraintError extends ValidationError implements CommonErrorProperties {\n  readonly parent: UniqueConstraintErrorParent;\n  readonly original: UniqueConstraintErrorParent;\n  readonly fields: Record<string, unknown>;\n  readonly sql: string;\n\n  constructor(options: UniqueConstraintErrorOptions) {\n    options = options ?? {};\n    options.parent = options.parent ?? { sql: '', name: '', message: '' };\n    options.message =\n      options.message || options.parent.message || 'Validation Error';\n    options.errors = options.errors ?? [];\n    super(options.message, options.errors, { stack: options.stack });\n\n    this.name = 'SequelizeUniqueConstraintError';\n    this.fields = options.fields ?? {};\n    this.parent = options.parent;\n    this.original = options.parent;\n    this.sql = options.parent.sql;\n  }\n}\n\nexport default UniqueConstraintError;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AACA,8BAAqD;AAiBrD,oCAAoC,gCAAiD;AAAA,EAMnF,YAAY,SAAuC;AAxBrD;AAyBI,cAAU,4BAAW;AACrB,YAAQ,SAAS,cAAQ,WAAR,YAAkB,EAAE,KAAK,IAAI,MAAM,IAAI,SAAS;AACjE,YAAQ,UACN,QAAQ,WAAW,QAAQ,OAAO,WAAW;AAC/C,YAAQ,SAAS,cAAQ,WAAR,YAAkB;AACnC,UAAM,QAAQ,SAAS,QAAQ,QAAQ,EAAE,OAAO,QAAQ;AAXjD;AACA;AACA;AACA;AAUP,SAAK,OAAO;AACZ,SAAK,SAAS,cAAQ,WAAR,YAAkB;AAChC,SAAK,SAAS,QAAQ;AACtB,SAAK,WAAW,QAAQ;AACxB,SAAK,MAAM,QAAQ,OAAO;AAAA;AAAA;AAI9B,IAAO,kCAAQ;",
+  "names": []
+}