@yieldstar/sqlite-runtime 0.5.0 → 0.6.0

package/dist/index-wx6vk994.js

@@ -0,0 +1,669 @@
+// src/sqlite-runtime.ts
+import { Runtime } from "@yieldstar/core";
+
+// src/sqlite-execution.ts
+import {
+  acknowledgeExecution,
+  claimExecution,
+  createExecutionState,
+  DEFAULT_REDELIVERY_TIMEOUT,
+  executionIdConflict,
+  executionNotFound,
+  isExecutionClaimable,
+  prepareExecutionAdmission,
+  requestExecutionWake,
+  toExecutionRecord
+} from "@yieldstar/core";
+
+// src/dao/executions-dao.ts
+import { nextClaimAt } from "@yieldstar/core";
+class ExecutionsDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS executions (
+        execution_id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL,
+        params TEXT NOT NULL,
+        context TEXT NOT NULL,
+        status TEXT NOT NULL,
+        outcome TEXT,
+        admitted_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        due_at INTEGER,
+        claim_token TEXT,
+        claimed_due_at INTEGER,
+        claim_expires_at INTEGER,
+        next_claim_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_executions_next_claim_at
+      ON executions(next_claim_at) WHERE next_claim_at IS NOT NULL;
+    `);
+  }
+  getState(executionId) {
+    const row = this.db.query(`SELECT * FROM executions WHERE execution_id = $executionId`).get({ $executionId: executionId });
+    return row ? toState(row) : undefined;
+  }
+  getClaimableIds(now) {
+    return this.db.query(`SELECT execution_id FROM executions
+         WHERE next_claim_at IS NOT NULL AND next_claim_at <= $now
+         ORDER BY next_claim_at, execution_id`).all({ $now: now }).map((row) => row.execution_id);
+  }
+  insertState(state) {
+    const result = this.db.query(`INSERT INTO executions (
+           execution_id, workflow_id, params, context, status, outcome,
+           admitted_at, updated_at, due_at, claim_token, claimed_due_at,
+           claim_expires_at, next_claim_at
+         ) VALUES (
+           $executionId, $workflowId, $params, $context, $status, $outcome,
+           $admittedAt, $updatedAt, $dueAt, $claimToken, $claimedDueAt,
+           $claimExpiresAt, $nextClaimAt
+         )
+         ON CONFLICT(execution_id) DO NOTHING`).run(toBindings(state));
+    return Number(result.changes) === 1;
+  }
+  updateState(state) {
+    this.db.query(`UPDATE executions SET
+           workflow_id = $workflowId,
+           params = $params,
+           context = $context,
+           status = $status,
+           outcome = $outcome,
+           admitted_at = $admittedAt,
+           updated_at = $updatedAt,
+           due_at = $dueAt,
+           claim_token = $claimToken,
+           claimed_due_at = $claimedDueAt,
+           claim_expires_at = $claimExpiresAt,
+           next_claim_at = $nextClaimAt
+         WHERE execution_id = $executionId`).run(toBindings(state));
+  }
+}
+function toState(row) {
+  return {
+    executionId: row.execution_id,
+    workflowId: row.workflow_id,
+    params: row.params,
+    context: row.context,
+    status: row.status,
+    outcome: row.outcome,
+    admittedAt: Number(row.admitted_at),
+    updatedAt: Number(row.updated_at),
+    dueAt: toNumberOrNull(row.due_at),
+    claimToken: row.claim_token,
+    claimedDueAt: toNumberOrNull(row.claimed_due_at),
+    claimExpiresAt: toNumberOrNull(row.claim_expires_at)
+  };
+}
+function toBindings(state) {
+  return {
+    $executionId: state.executionId,
+    $workflowId: state.workflowId,
+    $params: state.params,
+    $context: state.context,
+    $status: state.status,
+    $outcome: state.outcome,
+    $admittedAt: state.admittedAt,
+    $updatedAt: state.updatedAt,
+    $dueAt: state.dueAt,
+    $claimToken: state.claimToken,
+    $claimedDueAt: state.claimedDueAt,
+    $claimExpiresAt: state.claimExpiresAt,
+    $nextClaimAt: nextClaimAt(state)
+  };
+}
+function toNumberOrNull(value) {
+  return value === null ? null : Number(value);
+}
+
+// src/sqlite-transaction.ts
+function runTransaction(db, fn) {
+  db.run("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.run("COMMIT");
+    return result;
+  } catch (err) {
+    db.run("ROLLBACK");
+    throw err;
+  }
+}
+
+// src/sqlite-execution.ts
+class SqliteExecutionClient2 {
+  db;
+  executionsDao;
+  clock;
+  redeliveryTimeout;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.executionsDao = new ExecutionsDao(db);
+    this.clock = options.clock ?? (() => Date.now());
+    this.redeliveryTimeout = options.redeliveryTimeout ?? DEFAULT_REDELIVERY_TIMEOUT;
+  }
+  async admit(request) {
+    const prepared = prepareExecutionAdmission(request);
+    if (!prepared.ok) {
+      return {
+        status: "rejected",
+        code: prepared.code,
+        message: prepared.message
+      };
+    }
+    return runTransaction(this.db, () => {
+      const state = createExecutionState({
+        executionId: prepared.executionId,
+        workflowId: request.workflowId,
+        encoded: prepared.encoded,
+        now: this.clock()
+      });
+      if (!this.executionsDao.insertState(state)) {
+        return executionIdConflict(prepared.executionId);
+      }
+      return { status: "accepted", executionId: prepared.executionId };
+    });
+  }
+  async get(executionId) {
+    const state = this.executionsDao.getState(executionId);
+    return state ? toExecutionRecord(state) : undefined;
+  }
+  async requestWake(request) {
+    return runTransaction(this.db, () => {
+      const state = this.executionsDao.getState(request.executionId);
+      if (!state)
+        return executionNotFound(request.executionId);
+      const next = requestExecutionWake(state, request.wakeAt, this.clock());
+      if (!next)
+        return { status: "ignored" };
+      this.executionsDao.updateState(next);
+      return { status: "requested" };
+    });
+  }
+  async claimDue() {
+    return runTransaction(this.db, () => {
+      const now = this.clock();
+      const deliveries = [];
+      for (const executionId of this.executionsDao.getClaimableIds(now)) {
+        const state = this.executionsDao.getState(executionId);
+        if (!state || !isExecutionClaimable(state, now))
+          continue;
+        const token = crypto.randomUUID();
+        this.executionsDao.updateState(claimExecution(state, {
+          now,
+          token,
+          redeliveryTimeout: this.redeliveryTimeout
+        }));
+        deliveries.push({ executionId, token });
+      }
+      return deliveries;
+    });
+  }
+  async acknowledge(request) {
+    return runTransaction(this.db, () => {
+      const executionId = request.delivery.executionId;
+      const state = this.executionsDao.getState(executionId);
+      if (!state) {
+        throw new Error(executionNotFound(executionId).message);
+      }
+      const acknowledged = acknowledgeExecution(state, {
+        delivery: request.delivery,
+        outcome: request.outcome,
+        now: this.clock()
+      });
+      if (acknowledged.state !== state) {
+        this.executionsDao.updateState(acknowledged.state);
+      }
+      return acknowledged.result;
+    });
+  }
+  wakeInTransaction(executionId, wakeAt = this.clock()) {
+    const state = this.executionsDao.getState(executionId);
+    if (!state)
+      return;
+    const next = requestExecutionWake(state, wakeAt, this.clock());
+    if (next)
+      this.executionsDao.updateState(next);
+  }
+}
+
+// src/dao/step-response-dao.ts
+class StepResponsesDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS step_responses (
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        step_attempt INTEGER NOT NULL,
+        step_done BOOL NOT NULL,
+        step_response JSONB,
+        PRIMARY KEY (execution_id, step_key, step_attempt)
+      );
+      CREATE INDEX IF NOT EXISTS idx_execution_step_attempt 
+      ON step_responses(execution_id, step_key, step_attempt DESC);
+    `);
+  }
+  getAllSteps() {
+    const query = this.db.query(`SELECT * FROM step_responses`);
+    return query.all();
+  }
+  deleteAll() {
+    const query = this.db.query(`DELETE FROM step_responses`);
+    query.run();
+  }
+  getLatestStepResponse(executionId, stepKey) {
+    const query = this.db.query(`SELECT * FROM step_responses
+       WHERE execution_id = $executionId
+       AND step_key = $stepKey
+       ORDER BY step_attempt DESC LIMIT 1`);
+    const result = query.get({
+      $executionId: executionId,
+      $stepKey: stepKey
+    });
+    return result;
+  }
+  insertStepResponse(executionId, stepKey, stepAttempt, stepDone, stepResponseJson) {
+    const query = this.db.query(`INSERT INTO step_responses (execution_id, step_key, step_attempt, step_done, step_response) 
+        VALUES ($executionId, $stepKey, $stepAttempt, $stepDone, $stepResponse)`);
+    query.run({
+      $executionId: executionId,
+      $stepKey: stepKey,
+      $stepAttempt: stepAttempt,
+      $stepDone: stepDone,
+      $stepResponse: stepResponseJson
+    });
+  }
+}
+
+// src/dao/store-waiters-dao.ts
+class StoreWaitersDao {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.setupDb();
+  }
+  setupDb() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS store_waiters (
+        workflow_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        since_version INTEGER NOT NULL,
+        read_paths TEXT NOT NULL,
+        PRIMARY KEY (store_name, store_id, execution_id, step_key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_store_waiters_step
+      ON store_waiters(execution_id, step_key);
+    `);
+  }
+  upsertWaiter(waiter) {
+    this.db.query(`INSERT INTO store_waiters
+           (workflow_id, execution_id, step_key, store_name, store_id, since_version, read_paths)
+         VALUES
+           ($workflowId, $executionId, $stepKey, $storeName, $storeId, $sinceVersion, $readPaths)
+         ON CONFLICT(store_name, store_id, execution_id, step_key)
+         DO UPDATE SET
+           workflow_id = excluded.workflow_id,
+           since_version = excluded.since_version,
+           read_paths = excluded.read_paths`).run({
+      $workflowId: waiter.workflowId,
+      $executionId: waiter.executionId,
+      $stepKey: waiter.stepKey,
+      $storeName: waiter.storeName,
+      $storeId: waiter.storeId,
+      $sinceVersion: waiter.sinceVersion,
+      $readPaths: JSON.stringify(waiter.readPaths)
+    });
+  }
+  getStoreWaiters(storeName, storeId) {
+    return this.db.query(`SELECT * FROM store_waiters
+         WHERE store_name = $storeName AND store_id = $storeId`).all({ $storeName: storeName, $storeId: storeId });
+  }
+  deleteStoreWaiters(storeName, storeId) {
+    this.db.query(`DELETE FROM store_waiters WHERE store_name = $storeName AND store_id = $storeId`).run({ $storeName: storeName, $storeId: storeId });
+  }
+  deleteStepWaiters(executionId, stepKey) {
+    this.db.query(`DELETE FROM store_waiters WHERE execution_id = $executionId AND step_key = $stepKey`).run({ $executionId: executionId, $stepKey: stepKey });
+  }
+}
+
+// src/sqlite-heap.ts
+class SqliteHeapClient2 {
+  db;
+  stepResponsesDao;
+  storeWaitersDao;
+  constructor(db) {
+    this.db = db;
+    this.stepResponsesDao = new StepResponsesDao(db);
+    this.storeWaitersDao = new StoreWaitersDao(db);
+  }
+  async getAllSteps() {
+    return this.stepResponsesDao.getAllSteps();
+  }
+  async deleteAll() {
+    this.stepResponsesDao.deleteAll();
+  }
+  async readStep(params) {
+    const result = this.stepResponsesDao.getLatestStepResponse(params.executionId, params.stepKey);
+    if (!result?.step_response) {
+      return null;
+    }
+    return {
+      stepResponseJson: result.step_response,
+      meta: {
+        attempt: result.step_attempt,
+        done: Boolean(result.step_done)
+      }
+    };
+  }
+  async writeStep(params) {
+    runTransaction(this.db, () => {
+      this.stepResponsesDao.insertStepResponse(params.executionId, params.stepKey, params.stepAttempt, params.stepDone, params.stepResponseJson);
+      if (params.stepDone) {
+        this.storeWaitersDao.deleteStepWaiters(params.executionId, params.stepKey);
+      }
+    });
+  }
+}
+
+// src/sqlite-store.ts
+import { v7 as uuidv7 } from "uuid";
+import {
+  cloneStoreState,
+  CasStoreClient,
+  StoreNotFoundError,
+  storePathsIntersect,
+  validateStoreState
+} from "@yieldstar/core";
+class SqliteStoreClient2 extends CasStoreClient {
+  db;
+  executions;
+  storeWaitersDao;
+  constructor(params) {
+    super();
+    this.db = params.db;
+    this.executions = params.executions ?? new SqliteExecutionClient2(params.db);
+    this.setupDb();
+    this.storeWaitersDao = new StoreWaitersDao(params.db);
+  }
+  async getOrCreateStore(params) {
+    const existing = this.getStoreRow(params.definition.name, params.id);
+    if (existing) {
+      return toSnapshot(existing);
+    }
+    if (!params.initial) {
+      throw new StoreNotFoundError(params.definition.name, params.id);
+    }
+    const initialValue = params.initial;
+    const initial = typeof initialValue === "function" ? await initialValue() : initialValue;
+    const state = await validateStoreState(params.definition, initial);
+    return runTransaction(this.db, () => {
+      const existingTx = this.getStoreRow(params.definition.name, params.id);
+      if (existingTx) {
+        return toSnapshot(existingTx);
+      }
+      const instanceId = uuidv7();
+      this.db.query(`INSERT INTO stores (instance_id, store_name, store_id, version, state)
+           VALUES ($instanceId, $storeName, $storeId, 0, $state)`).run({
+        $instanceId: instanceId,
+        $storeName: params.definition.name,
+        $storeId: params.id,
+        $state: JSON.stringify(state)
+      });
+      return {
+        state: cloneStoreState(state),
+        instanceId,
+        version: 0
+      };
+    });
+  }
+  async getStore(params) {
+    const row = this.getStoreRow(params.definition.name, params.id);
+    if (!row) {
+      throw new StoreNotFoundError(params.definition.name, params.id);
+    }
+    return toSnapshot(row);
+  }
+  async getAppliedStoreStep(params) {
+    const row = this.getAppliedStepRow({
+      storeName: params.definition.name,
+      storeId: params.id,
+      stepId: params.stepId
+    });
+    return row ? { result: JSON.parse(row.result) } : undefined;
+  }
+  async commitStoreMutation(mutation) {
+    return runTransaction(this.db, () => {
+      if (mutation.stepId) {
+        const applied = this.getAppliedStepRow({
+          storeName: mutation.definition.name,
+          storeId: mutation.id,
+          stepId: mutation.stepId
+        });
+        if (applied) {
+          return {
+            status: "already-applied",
+            result: JSON.parse(applied.result)
+          };
+        }
+      }
+      const row = this.getStoreRow(mutation.definition.name, mutation.id);
+      if (!row) {
+        throw new StoreNotFoundError(mutation.definition.name, mutation.id);
+      }
+      if (row.instance_id !== mutation.expected.instanceId || row.version !== mutation.expected.version) {
+        return { status: "conflict", snapshot: toSnapshot(row) };
+      }
+      const version = mutation.expected.version + 1;
+      const changed = this.db.query(`UPDATE stores
+           SET version = $version, state = $state
+           WHERE instance_id = $instanceId AND version = $expectedVersion`).run({
+        $instanceId: mutation.expected.instanceId,
+        $expectedVersion: mutation.expected.version,
+        $version: version,
+        $state: JSON.stringify(mutation.nextState)
+      });
+      if (Number(changed.changes) !== 1) {
+        throw new Error("Store changed during its mutation transaction");
+      }
+      if (mutation.stepId) {
+        this.insertAppliedStepRow({
+          storeName: mutation.definition.name,
+          storeId: mutation.id,
+          stepId: mutation.stepId,
+          result: JSON.stringify(mutation.result)
+        });
+      }
+      const executionIds = this.selectMatchingExecutionIds({
+        storeName: mutation.definition.name,
+        storeId: mutation.id,
+        version,
+        changedPaths: mutation.changedPaths
+      });
+      for (const executionId of executionIds) {
+        this.executions.wakeInTransaction(executionId);
+      }
+      return { status: "committed" };
+    });
+  }
+  async listStores(definition) {
+    const rows = this.db.query(`SELECT store_id FROM stores
+         WHERE store_name = $storeName
+         ORDER BY store_id ASC`).all({ $storeName: definition.name });
+    return rows.map((row) => row.store_id);
+  }
+  async deleteStore(params) {
+    runTransaction(this.db, () => {
+      this.db.query(`DELETE FROM stores WHERE store_name = $storeName AND store_id = $storeId`).run({
+        $storeName: params.definition.name,
+        $storeId: params.id
+      });
+      this.storeWaitersDao.deleteStoreWaiters(params.definition.name, params.id);
+    });
+  }
+  async deleteStoreFrom(params) {
+    return runTransaction(this.db, () => {
+      if (params.stepId) {
+        const applied = this.getAppliedStepRow({
+          storeName: params.definition.name,
+          storeId: params.id,
+          stepId: params.stepId
+        });
+        if (applied) {
+          return JSON.parse(applied.result);
+        }
+      }
+      this.assertSnapshotHasInstanceId(params.snapshot);
+      const row = this.getStoreRow(params.definition.name, params.id);
+      if (!row) {
+        return {
+          deleted: false,
+          reason: "not-found",
+          expectedInstanceId: params.snapshot.instanceId,
+          expectedVersion: params.snapshot.version
+        };
+      }
+      if (row.instance_id !== params.snapshot.instanceId || row.version !== params.snapshot.version) {
+        return {
+          deleted: false,
+          reason: "conflict",
+          expectedInstanceId: params.snapshot.instanceId,
+          actualInstanceId: row.instance_id,
+          expectedVersion: params.snapshot.version,
+          actualVersion: row.version
+        };
+      }
+      this.storeWaitersDao.deleteStoreWaiters(params.definition.name, params.id);
+      this.db.query(`DELETE FROM stores WHERE instance_id = $instanceId`).run({ $instanceId: row.instance_id });
+      const result = { deleted: true };
+      if (params.stepId) {
+        this.insertAppliedStepRow({
+          storeName: params.definition.name,
+          storeId: params.id,
+          stepId: params.stepId,
+          result: JSON.stringify(result)
+        });
+      }
+      return result;
+    });
+  }
+  async registerWaiter(waiter) {
+    runTransaction(this.db, () => {
+      this.storeWaitersDao.upsertWaiter(waiter);
+      const row = this.getStoreRow(waiter.storeName, waiter.storeId);
+      if (!row || row.instance_id !== waiter.instanceId || row.version > waiter.sinceVersion) {
+        this.executions.wakeInTransaction(waiter.executionId);
+      }
+    });
+  }
+  setupDb() {
+    this.createStoresTable();
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS store_applied_steps (
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        step_key TEXT NOT NULL,
+        result TEXT NOT NULL,
+        PRIMARY KEY (store_name, store_id, execution_id, step_key)
+      );
+    `);
+  }
+  createStoresTable() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS stores (
+        instance_id TEXT PRIMARY KEY,
+        store_name TEXT NOT NULL,
+        store_id TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        state TEXT NOT NULL,
+        UNIQUE (store_name, store_id)
+      )
+    `);
+  }
+  getAppliedStepRow(params) {
+    return this.db.query(`SELECT result FROM store_applied_steps
+         WHERE store_name = $storeName
+           AND store_id = $storeId
+           AND execution_id = $executionId
+           AND step_key = $stepKey`).get({
+      $storeName: params.storeName,
+      $storeId: params.storeId,
+      $executionId: params.stepId.executionId,
+      $stepKey: params.stepId.stepKey
+    });
+  }
+  insertAppliedStepRow(params) {
+    this.db.query(`INSERT INTO store_applied_steps
+           (store_name, store_id, execution_id, step_key, result)
+         VALUES
+           ($storeName, $storeId, $executionId, $stepKey, $result)`).run({
+      $storeName: params.storeName,
+      $storeId: params.storeId,
+      $executionId: params.stepId.executionId,
+      $stepKey: params.stepId.stepKey,
+      $result: params.result
+    });
+  }
+  getStoreRow(storeName, storeId) {
+    return this.db.query(`SELECT instance_id, state, version FROM stores
+         WHERE store_name = $storeName AND store_id = $storeId`).get({
+      $storeName: storeName,
+      $storeId: storeId
+    });
+  }
+  selectMatchingExecutionIds(params) {
+    const executionIds = new Set;
+    const rows = this.storeWaitersDao.getStoreWaiters(params.storeName, params.storeId);
+    for (const row of rows) {
+      if (row.since_version >= params.version)
+        continue;
+      const readPaths = JSON.parse(row.read_paths);
+      if (!storePathsIntersect(readPaths, params.changedPaths))
+        continue;
+      executionIds.add(row.execution_id);
+    }
+    return executionIds;
+  }
+  assertSnapshotHasInstanceId(snapshot) {
+    if (!snapshot.instanceId) {
+      throw new Error("Store snapshot is missing instanceId; read a fresh snapshot");
+    }
+  }
+}
+function toSnapshot(row) {
+  return {
+    state: JSON.parse(row.state),
+    instanceId: row.instance_id,
+    version: row.version
+  };
+}
+
+// src/sqlite-runtime.ts
+class SqliteRuntime2 extends Runtime {
+  clock;
+  executions;
+  heap;
+  stores;
+  constructor(db, options = {}) {
+    super();
+    this.clock = options.clock ?? (() => Date.now());
+    this.executions = new SqliteExecutionClient2(db, {
+      ...options,
+      clock: this.clock
+    });
+    this.heap = new SqliteHeapClient2(db);
+    this.stores = new SqliteStoreClient2({ db, executions: this.executions });
+  }
+}
+export { SqliteExecutionClient2, SqliteHeapClient2, SqliteStoreClient2, SqliteRuntime2 };

package/dist/index.d.ts

@@ -1,9 +1,8 @@
+export { SqliteRuntime, type SqliteRuntimeOptions } from "./sqlite-runtime";
+export { SqliteExecutionClient, type SqliteExecutionClientOptions, } from "./sqlite-execution";
+export { SqliteEffectClient } from "./sqlite-effect";
 export { SqliteHeapClient } from "./sqlite-heap";
 export { SqliteStoreClient } from "./sqlite-store";
-export { SqliteSchedulerClient } from "./sqlite-scheduler";
-export { SqliteEventLoop } from "./sqlite-event-loop";
-export { SqliteTaskQueueClient } from "./sqlite-task-queue";
-export { SqliteTimersClient } from "./sqlite-timers";
 export type { SqliteDriver, SqliteParameters, SqliteParameterValue, SqliteRunResult, SqliteStatement, } from "./sqlite-driver";
 export type { SqliteDbOpts } from "./sqlite-db";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}