peta-orm 0.2.4 → 0.2.6

package/dist/index-ddxdqxz6.js

@@ -0,0 +1,636 @@
+// @bun
+import {
+  __require
+} from "./index-k18nf2r7.js";
+
+// src/errors/errors.ts
+class ValidationError extends Error {
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+}
+
+class ModelNotFoundError extends Error {
+  modelClass;
+  id;
+  constructor(modelClass, id) {
+    const msg = modelClass ? `${modelClass} with id ${id} not found` : "Model not found";
+    super(msg);
+    this.name = "ModelNotFoundError";
+    this.modelClass = modelClass;
+    this.id = id;
+  }
+}
+
+class RelationNotFoundError extends Error {
+  modelClass;
+  relationName;
+  constructor(modelClass, relationName) {
+    const msg = modelClass ? `Relation "${relationName}" not found on ${modelClass}` : "Relation not found";
+    super(msg);
+    this.name = "RelationNotFoundError";
+    this.modelClass = modelClass;
+    this.relationName = relationName;
+  }
+}
+
+class ModelNotRegisteredError extends Error {
+  modelClass;
+  constructor(modelClass) {
+    const msg = modelClass ? `${modelClass} is not registered with Peta` : "Model not registered with Peta";
+    super(msg);
+    this.name = "ModelNotRegisteredError";
+    this.modelClass = modelClass;
+  }
+}
+var UNIQUE_CODES = new Set([
+  "SQLITE_CONSTRAINT_UNIQUE",
+  "SQLITE_CONSTRAINT_PRIMARYKEY",
+  "23505",
+  "ER_DUP_ENTRY"
+]);
+var FOREIGN_KEY_CODES = new Set([
+  "SQLITE_CONSTRAINT_FOREIGNKEY",
+  "23503",
+  "ER_NO_REFERENCED_ROW_2"
+]);
+
+class DatabaseError extends Error {
+  code;
+  cause;
+  table;
+  constructor(code, message, cause, table) {
+    super(message);
+    this.name = "DatabaseError";
+    this.code = code;
+    this.cause = cause;
+    this.table = table;
+  }
+}
+function normalizeError(e, table) {
+  if (!e || typeof e !== "object")
+    return null;
+  const err = e;
+  if (typeof err.code === "string") {
+    if (UNIQUE_CODES.has(err.code)) {
+      const col = typeof err.column === "string" ? ` on ${err.column}` : "";
+      return new DatabaseError("UNIQUE_CONSTRAINT", `Unique constraint violation${col}`, e, table);
+    }
+    if (FOREIGN_KEY_CODES.has(err.code)) {
+      return new DatabaseError("FOREIGN_KEY_CONSTRAINT", "Foreign key constraint violation", e, table);
+    }
+  }
+  return null;
+}
+
+// src/builder/delete-builder.ts
+class DeleteBuilder {
+  #modelClass;
+  #kysely;
+  constructor(modelClass, peta, kysely) {
+    this.#modelClass = modelClass;
+    this.#kysely = kysely ?? peta.kysely;
+  }
+  async execute(id) {
+    try {
+      await this.#kysely.deleteFrom(this.#modelClass.table).where("id", "=", id).execute();
+    } catch (e) {
+      const normalized = normalizeError(e, this.#modelClass.table);
+      if (normalized)
+        throw normalized;
+      throw e;
+    }
+  }
+}
+// src/builder/eager-loader.ts
+class EagerLoader {
+  async load(modelClass, relationData, models, names) {
+    for (const name of names) {
+      await this.#loadRelation(modelClass, relationData, models, name);
+    }
+  }
+  async loadRelated(models, el, modelClass) {
+    const { name, constraints } = el;
+    await this.#loadRelation(modelClass, {}, models, name, constraints);
+  }
+  async#loadRelation(modelClass, relationData, models, name, constraints) {
+    const dotIndex = name.indexOf(".");
+    if (dotIndex > 0) {
+      const primary = name.slice(0, dotIndex);
+      const nested = name.slice(dotIndex + 1);
+      const relation2 = modelClass.relations[primary];
+      if (!relation2)
+        throw new RelationNotFoundError(modelClass.table, primary);
+      await this.#loadRelation(modelClass, relationData, models, primary, null);
+      const allRelated = [];
+      for (const m of models) {
+        const rel = m.$getRelation(primary);
+        if (Array.isArray(rel))
+          allRelated.push(...rel);
+      }
+      if (allRelated.length > 0) {
+        await this.#loadRelation(relation2.relatedModelClass, {}, allRelated, nested, null);
+      }
+      return;
+    }
+    const relation = modelClass.relations[name];
+    if (!relation)
+      throw new RelationNotFoundError(modelClass.table, name);
+    await relation.loadEager(models, name, constraints);
+  }
+}
+// src/builder/query-builder.ts
+var SAFE_COL = /^[a-zA-Z_][a-zA-Z0-9_.]*$/;
+
+class ModelQueryBuilder {
+  #modelClass;
+  #peta;
+  #kysely;
+  #qb;
+  #eagerLoads = [];
+  #withTrashed = false;
+  #onlyTrashed = false;
+  #omitScopes = new Set;
+  constructor(modelClass, peta, kysely) {
+    this.#modelClass = modelClass;
+    this.#peta = peta;
+    this.#kysely = kysely ?? peta.kysely;
+    this.#qb = this.#kysely.selectFrom(modelClass.table);
+  }
+  get peta() {
+    return this.#peta;
+  }
+  clone() {
+    const qb = new ModelQueryBuilder(this.#modelClass, this.#peta);
+    qb.#qb = this.#qb;
+    qb.#eagerLoads = [...this.#eagerLoads];
+    qb.#withTrashed = this.#withTrashed;
+    qb.#onlyTrashed = this.#onlyTrashed;
+    qb.#omitScopes = new Set(this.#omitScopes);
+    return qb;
+  }
+  withoutGlobalScope(name) {
+    this.#omitScopes.add(name);
+    return this;
+  }
+  when(condition, callback) {
+    if (condition)
+      return callback(this);
+    return this;
+  }
+  unless(condition, callback) {
+    if (!condition)
+      return callback(this);
+    return this;
+  }
+  async execute() {
+    const scopes = this.#modelClass.getGlobalScopes?.();
+    if (scopes) {
+      for (const [name, fn] of scopes) {
+        if (!this.#omitScopes.has(name)) {
+          fn(this);
+        }
+      }
+    }
+    if (!this.#withTrashed && "deletedAt" in this.#modelClass.columns) {
+      this.#qb = this.#qb.where("deletedAt", "is", null);
+    }
+    if (this.#onlyTrashed) {
+      this.#qb = this.#qb.where("deletedAt", "is not", null);
+    }
+    const rows = await this.#qb.selectAll().execute();
+    const models = rows.map((row) => this.#modelClass.hydrate(row));
+    if (this.#eagerLoads.length > 0) {
+      const loader = new EagerLoader;
+      for (const el of this.#eagerLoads) {
+        await loader.loadRelated(models, el, this.#modelClass);
+      }
+    }
+    return models;
+  }
+  async collect() {
+    const items = await this.execute();
+    const { Collection: Col } = await import("./collection-wwtv7qmv.js");
+    return new Col(items);
+  }
+  async executeTakeFirst() {
+    const rows = await this.execute();
+    return rows[0];
+  }
+  async executeTakeFirstOrThrow() {
+    const row = await this.executeTakeFirst();
+    if (!row)
+      throw new ModelNotFoundError(this.#modelClass.table);
+    return row;
+  }
+  async find(id) {
+    return this.clone().where("id", "=", id).executeTakeFirst();
+  }
+  async findOrFail(id) {
+    return this.clone().where("id", "=", id).executeTakeFirstOrThrow();
+  }
+  async first() {
+    return this.clone().limit(1).executeTakeFirst();
+  }
+  toSQL() {
+    const compiled = this.#qb.compile();
+    return { sql: compiled.sql, parameters: compiled.parameters };
+  }
+  async count() {
+    const result = await this.#qb.select((eb) => eb.fn.countAll().as("count")).executeTakeFirst();
+    return Number(result?.count ?? 0);
+  }
+  async sum(column) {
+    const result = await this.#qb.select((eb) => eb.fn.sum(column).as("sum")).executeTakeFirst();
+    return Number(result?.sum ?? 0);
+  }
+  async avg(column) {
+    const result = await this.#qb.select((eb) => eb.fn.avg(column).as("avg")).executeTakeFirst();
+    return Number(result?.avg ?? 0);
+  }
+  async min(column) {
+    const result = await this.#qb.select((eb) => eb.fn.min(column).as("min")).executeTakeFirst();
+    return Number(result?.min ?? 0);
+  }
+  async max(column) {
+    const result = await this.#qb.select((eb) => eb.fn.max(column).as("max")).executeTakeFirst();
+    return Number(result?.max ?? 0);
+  }
+  async chunk(size, callback) {
+    let page = 1;
+    while (true) {
+      const items = await this.clone().limit(size).offset((page - 1) * size).execute();
+      if (items.length === 0)
+        break;
+      await callback(items);
+      if (items.length < size)
+        break;
+      page++;
+    }
+  }
+  async paginate(page, perPage = 20) {
+    page = Math.max(1, Math.floor(page));
+    perPage = Math.max(1, Math.min(perPage, 1000));
+    const total = await this.clone().count();
+    const items = await this.clone().limit(perPage).offset((page - 1) * perPage).execute();
+    const { Paginator } = await import("./paginator-tmp4hxj5.js");
+    return new Paginator(items, total, perPage, page);
+  }
+  with(...relations) {
+    for (const arg of relations) {
+      if (typeof arg === "string") {
+        this.#eagerLoads.push({ name: arg, constraints: null });
+      } else if (arg && typeof arg === "object") {
+        for (const [name, constraints] of Object.entries(arg)) {
+          this.#eagerLoads.push({
+            name,
+            constraints: typeof constraints === "function" ? constraints : null
+          });
+        }
+      }
+    }
+    return this;
+  }
+  async updateMany(data) {
+    const result = await this.#kysely.updateTable(this.#modelClass.table).set(data).executeTakeFirst();
+    return Number(result.numUpdatedRows ?? 0);
+  }
+  async deleteMany() {
+    const result = await this.#kysely.deleteFrom(this.#modelClass.table).executeTakeFirst();
+    return Number(result.numDeletedRows ?? 0);
+  }
+  withTrashed() {
+    this.#withTrashed = true;
+    return this;
+  }
+  onlyTrashed() {
+    this.#withTrashed = true;
+    this.#onlyTrashed = true;
+    return this;
+  }
+  whereIn(column, values) {
+    if (values.length === 0) {
+      this.#qb = this.#qb.where("1", "=", "0");
+    } else {
+      this.#qb = this.#qb.where(column, "in", values);
+    }
+    return this;
+  }
+  whereInPivot(column, values) {
+    if (values.length === 0) {
+      this.#qb = this.#qb.where("1", "=", "0");
+    } else {
+      this.#qb = this.#qb.where(column, "in", values);
+    }
+    return this;
+  }
+  has(relationName) {
+    return this.#whereExists(relationName, undefined, true);
+  }
+  whereHas(relationName, _callback) {
+    return this.#whereExists(relationName, _callback, true);
+  }
+  whereDoesntHave(relationName, _callback) {
+    return this.#whereExists(relationName, _callback, false);
+  }
+  #whereExists(relationName, _callback, exists = true) {
+    const relation = this.#modelClass.relations[relationName];
+    if (!relation) {
+      throw new RelationNotFoundError(this.#modelClass.table, relationName);
+    }
+    const relatedTable = relation.relatedModelClass.table;
+    const foreignKey = relation.foreignKey;
+    const localKey = relation.localKey;
+    const subQb = this.#kysely.selectFrom(`${relatedTable} as ${relatedTable}_exists`).selectAll().whereRef(`${relatedTable}_exists.${foreignKey}`, "=", `${this.#modelClass.table}.${localKey}`);
+    this.#qb = this.#qb.where((eb) => exists ? eb.exists(subQb) : eb.not(eb.exists(subQb)));
+    return this;
+  }
+  #col(ref) {
+    if (!SAFE_COL.test(ref))
+      throw new Error(`Invalid column reference: ${ref}`);
+    return ref;
+  }
+  #safeWhere(column, operator, value) {
+    const col = this.#col(column);
+    this.#qb = this.#qb.where(col, operator, value);
+  }
+  where(...args) {
+    this.#safeWhere(String(args[0]), args[1], args[2]);
+    return this;
+  }
+  whereRef(col1, operator, col2) {
+    this.#qb = this.#qb.whereRef(this.#col(col1), operator, this.#col(col2));
+    return this;
+  }
+  orWhere(...args) {
+    this.#safeWhere(String(args[0]), args[1], args[2]);
+    return this;
+  }
+  orderBy(column, direction) {
+    const col = this.#col(column);
+    if (direction) {
+      this.#qb = this.#qb.orderBy(col, direction);
+    } else {
+      this.#qb = this.#qb.orderBy(col);
+    }
+    return this;
+  }
+  limit(n) {
+    this.#qb = this.#qb.limit(n);
+    return this;
+  }
+  offset(n) {
+    this.#qb = this.#qb.offset(n);
+    return this;
+  }
+  select(...columns) {
+    this.#qb = this.#qb.select(columns.map((c) => this.#col(c)));
+    return this;
+  }
+  selectAll(table) {
+    if (table) {
+      this.#qb = this.#qb.selectAll(this.#col(table));
+    } else {
+      this.#qb = this.#qb.selectAll();
+    }
+    return this;
+  }
+  innerJoin(table, lhs, rhs) {
+    this.#qb = this.#qb.innerJoin(table, this.#col(lhs), this.#col(rhs));
+    return this;
+  }
+  leftJoin(table, lhs, rhs) {
+    this.#qb = this.#qb.leftJoin(table, this.#col(lhs), this.#col(rhs));
+    return this;
+  }
+  groupBy(...columns) {
+    this.#qb = this.#qb.groupBy(columns.map((c) => this.#col(c)));
+    return this;
+  }
+  having(column, operator, value) {
+    this.#qb = this.#qb.having(this.#col(column), operator, value);
+    return this;
+  }
+}
+// src/builder/update-builder.ts
+class UpdateBuilder {
+  #modelClass;
+  #kysely;
+  constructor(modelClass, peta, kysely) {
+    this.#modelClass = modelClass;
+    this.#kysely = kysely ?? peta.kysely;
+  }
+  async execute(id, data) {
+    const columns = this.#modelClass.columns;
+    for (const [key, col] of Object.entries(columns)) {
+      const value = data[key];
+      if (value !== undefined) {
+        try {
+          col.assert(value);
+        } catch (e) {
+          if (e instanceof ValidationError) {
+            throw new ValidationError(`${key}: ${e.message}`, e.errors);
+          }
+          throw e;
+        }
+      }
+    }
+    let row;
+    try {
+      row = await this.#kysely.updateTable(this.#modelClass.table).set(data).where("id", "=", id).returningAll().executeTakeFirst();
+    } catch (e) {
+      const normalized = normalizeError(e, this.#modelClass.table);
+      if (normalized)
+        throw normalized;
+      throw e;
+    }
+    if (!row)
+      throw new ModelNotFoundError(this.#modelClass.table, id);
+    return this.#modelClass.hydrate(row);
+  }
+}
+// src/collection/collection.ts
+class Collection {
+  #items = [];
+  constructor(items = []) {
+    this.#items = [...items];
+  }
+  get length() {
+    return this.#items.length;
+  }
+  [Symbol.iterator]() {
+    return this.#items[Symbol.iterator]();
+  }
+  at(index) {
+    return this.#items[index];
+  }
+  first() {
+    return this.#items[0];
+  }
+  last() {
+    return this.#items[this.#items.length - 1];
+  }
+  all() {
+    return [...this.#items];
+  }
+  findBy(id) {
+    return this.#items.find((item) => item.get("id") === id);
+  }
+  pluck(key) {
+    return this.#items.map((item) => item.get(key));
+  }
+  groupBy(key) {
+    const result = {};
+    for (const item of this.#items) {
+      const k = String(item.get(key));
+      if (!result[k])
+        result[k] = [];
+      result[k].push(item);
+    }
+    return result;
+  }
+  keyBy(key) {
+    const result = {};
+    for (const item of this.#items) {
+      const k = String(item.get(key));
+      result[k] = item;
+    }
+    return result;
+  }
+  toJSON() {
+    return this.#items.map((item) => item.$toJSON());
+  }
+  map(fn) {
+    return this.#items.map(fn);
+  }
+  filter(fn) {
+    return new Collection(this.#items.filter(fn));
+  }
+  reduce(fn, initial) {
+    return this.#items.reduce(fn, initial);
+  }
+  forEach(fn) {
+    this.#items.forEach(fn);
+  }
+  find(fn) {
+    return this.#items.find(fn);
+  }
+  some(fn) {
+    return this.#items.some(fn);
+  }
+  includes(item) {
+    return this.#items.includes(item);
+  }
+  async load(...relations) {
+    if (this.#items.length === 0)
+      return this;
+    const modelClass = this.#items[0].constructor;
+    const loader = new EagerLoader;
+    await loader.load(modelClass, {}, this.#items, relations);
+    return this;
+  }
+  get(key) {
+    return this.#items.map((item) => item.get(key));
+  }
+  isEmpty() {
+    return this.#items.length === 0;
+  }
+  isNotEmpty() {
+    return this.#items.length > 0;
+  }
+  sum(key) {
+    return this.#items.reduce((acc, item) => acc + (Number(item.get(key)) || 0), 0);
+  }
+  avg(key) {
+    if (this.#items.length === 0)
+      return 0;
+    return this.sum(key) / this.#items.length;
+  }
+  min(key) {
+    const values = this.pluck(key);
+    if (values.length === 0)
+      return;
+    return Math.min(...values.filter((v) => typeof v === "number"));
+  }
+  max(key) {
+    const values = this.pluck(key);
+    if (values.length === 0)
+      return;
+    return Math.max(...values.filter((v) => typeof v === "number"));
+  }
+  contains(value, key) {
+    if (key) {
+      return this.#items.some((item) => item.get(key) === value);
+    }
+    return this.#items.some((item) => item === value);
+  }
+  unique(key) {
+    const seen = new Set;
+    return new Collection(this.#items.filter((item) => {
+      const val = item.get(key);
+      if (seen.has(val))
+        return false;
+      seen.add(val);
+      return true;
+    }));
+  }
+  sortBy(key, direction = "asc") {
+    const items = [...this.#items].sort((a, b) => {
+      const av = String(a.get(key));
+      const bv = String(b.get(key));
+      if (av < bv)
+        return direction === "asc" ? -1 : 1;
+      if (av > bv)
+        return direction === "asc" ? 1 : -1;
+      return 0;
+    });
+    return new Collection(items);
+  }
+  shuffle() {
+    const items = [...this.#items];
+    for (let i = items.length - 1;i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      const tmp = items[i];
+      items[i] = items[j];
+      items[j] = tmp;
+    }
+    return new Collection(items);
+  }
+  take(n) {
+    return new Collection(this.#items.slice(0, n));
+  }
+  skip(n) {
+    return new Collection(this.#items.slice(n));
+  }
+  chunk(size) {
+    const chunks = [];
+    for (let i = 0;i < this.#items.length; i += size) {
+      chunks.push(new Collection(this.#items.slice(i, i + size)));
+    }
+    return chunks;
+  }
+  each(fn) {
+    this.#items.forEach(fn);
+    return this;
+  }
+  diff(other) {
+    const ids = new Set(other.pluck("id"));
+    return new Collection(this.#items.filter((item) => !ids.has(item.get("id"))));
+  }
+  intersect(other) {
+    const ids = new Set(other.pluck("id"));
+    return new Collection(this.#items.filter((item) => ids.has(item.get("id"))));
+  }
+  push(...items) {
+    this.#items.push(...items);
+  }
+  concat(other) {
+    const otherItems = other instanceof Collection ? other.all() : other;
+    return new Collection([...this.#items, ...otherItems]);
+  }
+}
+
+export { ValidationError, ModelNotFoundError, RelationNotFoundError, ModelNotRegisteredError, DatabaseError, normalizeError, DeleteBuilder, EagerLoader, Collection, ModelQueryBuilder, UpdateBuilder };

package/dist/{index-bv1vk6ec.js → index-qb301480.js}

@@ -31,7 +31,7 @@ import {
   parseTable,
   parseValueExpression,
   preventAwait
-} from "./index-gacxptb4.js";
+} from "./index-sm1xx8gs.js";
 import {
   __require
 } from "./index-k18nf2r7.js";

package/dist/{index-gacxptb4.js → index-sm1xx8gs.js}

@@ -7473,7 +7473,8 @@ function validateTransactionSettings(settings) {
 // src/peta.ts
 import { resolve } from "path";
 function isModelClass(value) {
-  return typeof value === "function" && typeof value.table === "string" && value.table.length > 0 && typeof value.columns === "object" && value.columns !== null;
+  const v = value;
+  return typeof value === "function" && typeof v.table === "string" && v.table.length > 0 && typeof v.columns === "object" && v.columns !== null;
 }
 
 class Peta {
@@ -7570,6 +7571,14 @@ class Relation {
   get relatedModelClass() {
     return resolve2(this.#relatedThunk);
   }
+  async loadEager(models, relationName, constraints) {
+    const qb = this.relatedModelClass.query();
+    this.addEagerConstraints(qb, models);
+    if (constraints)
+      constraints(qb);
+    const results = await qb.execute();
+    this.match(models, results, relationName);
+  }
 }
 
 class HasMany extends Relation {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { WithArg } from "./builder";
-export { DeleteBuilder, EagerLoader, InsertBuilder, ModelQueryBuilder, UpdateBuilder } from "./builder";
+export { DeleteBuilder, EagerLoader, ModelQueryBuilder, UpdateBuilder } from "./builder";
 export { Collection } from "./collection/collection";
 export { ArkTypeSchemaConfig } from "./columns/arktype-config";
 export type { ColumnShape, ColumnValue } from "./columns/column";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACvG,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAC3C,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAC3G,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE5E,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,YAAY,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAC1F,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChE,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAC7F,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAC3C,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAC3G,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE5E,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,YAAY,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAC1F,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChE,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAC7F,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA"}