@enbox/dwn-sql-store 0.0.2 → 0.0.4

package/dist/cjs/main.js

@@ -1,3784 +0,0 @@
-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 __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames(from3))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// dist/esm/src/main.js
-var main_exports = {};
-__export(main_exports, {
-  DataStoreSql: () => DataStoreSql,
-  EventLogSql: () => EventLogSql,
-  MessageStoreSql: () => MessageStoreSql,
-  MysqlDialect: () => MysqlDialect,
-  PostgresDialect: () => PostgresDialect,
-  ResumableTaskStoreSql: () => ResumableTaskStoreSql,
-  SqliteDialect: () => SqliteDialect
-});
-module.exports = __toCommonJS(main_exports);
-
-// dist/esm/src/dialect/mysql-dialect.js
-var import_kysely = require("kysely");
-var MysqlDialect = class extends import_kysely.MysqlDialect {
-  name = "MySQL";
-  isStreamingSupported = true;
-  async hasTable(db, tableName) {
-    const result = await db.selectFrom("information_schema.tables").select("table_name").where("table_name", "=", tableName).execute();
-    return result.length > 0;
-  }
-  addAutoIncrementingColumn(builder, columnName, callback) {
-    return builder.addColumn(columnName, "integer", (col) => {
-      col = col.autoIncrement();
-      if (callback) {
-        col = callback(col);
-      }
-      return col;
-    });
-  }
-  addBlobColumn(builder, columnName, callback) {
-    return builder.addColumn(columnName, "blob", callback);
-  }
-  /**
-   * In MySQL, the ForeignKey name it creates in `mysql` will be in the following format:
-   * `${referenceTable}_${referenceColumnName}__${tableName}_${columnName}`
-   * ex: if the reference table is `users` and the reference column is `id` and the table is `profiles` and the column is `userId`,
-   * the resulting name for the foreign key is: `users_id__profiles_userId`
-   */
-  addReferencedColumn(builder, tableName, columnName, columnType, referenceTable, referenceColumnName, onDeleteAction) {
-    return builder.addColumn(columnName, columnType, (col) => col.notNull()).addForeignKeyConstraint(`${referenceTable}_${referenceColumnName}__${tableName}_${columnName}`, [columnName], referenceTable, [referenceColumnName], (constraint) => constraint.onDelete(onDeleteAction));
-  }
-  insertThenReturnId(db, table, values, _returning) {
-    return db.insertInto(table).values(values);
-  }
-};
-
-// dist/esm/src/dialect/postgres-dialect.js
-var import_kysely2 = require("kysely");
-var PostgresDialect = class extends import_kysely2.PostgresDialect {
-  name = "PostgreSQL";
-  isStreamingSupported = true;
-  async hasTable(db, tableName) {
-    const result = await db.selectFrom("information_schema.tables").select("table_name").where("table_name", "=", tableName).execute();
-    return result.length > 0;
-  }
-  addAutoIncrementingColumn(builder, columnName, callback) {
-    return builder.addColumn(columnName, "serial", callback);
-  }
-  addBlobColumn(builder, columnName, callback) {
-    return builder.addColumn(columnName, "bytea", callback);
-  }
-  addReferencedColumn(builder, _tableName, columnName, columnType, referenceTable, referenceColumnName, onDeleteAction) {
-    return builder.addColumn(columnName, columnType, (col) => col.notNull().references(`${referenceTable}.${referenceColumnName}`).onDelete(onDeleteAction));
-  }
-  insertThenReturnId(db, table, values, returning) {
-    return db.insertInto(table).values(values).returning(returning);
-  }
-};
-
-// dist/esm/src/dialect/sqlite-dialect.js
-var import_kysely3 = require("kysely");
-var SqliteDialect = class extends import_kysely3.SqliteDialect {
-  name = "SQLite";
-  isStreamingSupported = false;
-  async hasTable(db, tableName) {
-    const result = await db.selectFrom("sqlite_master").select("name").where("type", "=", "table").where("name", "=", tableName).execute();
-    return result.length > 0;
-  }
-  addAutoIncrementingColumn(builder, columnName, callback) {
-    return builder.addColumn(columnName, "integer", (col) => {
-      col = col.autoIncrement();
-      if (callback) {
-        col = callback(col);
-      }
-      return col;
-    });
-  }
-  addBlobColumn(builder, columnName, callback) {
-    return builder.addColumn(columnName, "blob", callback);
-  }
-  addReferencedColumn(builder, _tableName, columnName, columnType, referenceTable, referenceColumnName, onDeleteAction) {
-    return builder.addColumn(columnName, columnType, (col) => col.notNull().references(`${referenceTable}.${referenceColumnName}`).onDelete(onDeleteAction));
-  }
-  insertThenReturnId(db, table, values, returning) {
-    return db.insertInto(table).values(values).returning(returning);
-  }
-};
-
-// dist/esm/src/data-store-sql.js
-var import_dwn_sdk_js = require("@enbox/dwn-sdk-js");
-var import_kysely4 = require("kysely");
-var import_readable_stream = require("readable-stream");
-var DataStoreSql = class {
-  #dialect;
-  #db = null;
-  constructor(dialect) {
-    this.#dialect = dialect;
-  }
-  async open() {
-    if (this.#db) {
-      return;
-    }
-    this.#db = new import_kysely4.Kysely({ dialect: this.#dialect });
-    const tableName = "dataStore";
-    const tableExists = await this.#dialect.hasTable(this.#db, tableName);
-    if (tableExists) {
-      return;
-    }
-    let table = this.#db.schema.createTable(tableName).ifNotExists().addColumn("tenant", "varchar(255)", (col) => col.notNull()).addColumn("recordId", "varchar(60)", (col) => col.notNull()).addColumn("dataCid", "varchar(60)", (col) => col.notNull());
-    table = this.#dialect.addAutoIncrementingColumn(table, "id", (col) => col.primaryKey());
-    table = this.#dialect.addBlobColumn(table, "data", (col) => col.notNull());
-    await table.execute();
-    await this.#db.schema.createIndex("tenant_recordId_dataCid").on(tableName).columns(["tenant", "recordId", "dataCid"]).unique().execute();
-  }
-  async close() {
-    await this.#db?.destroy();
-    this.#db = null;
-  }
-  async get(tenant, recordId, dataCid) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `get`.");
-    }
-    const result = await this.#db.selectFrom("dataStore").selectAll().where("tenant", "=", tenant).where("recordId", "=", recordId).where("dataCid", "=", dataCid).executeTakeFirst();
-    if (!result) {
-      return void 0;
-    }
-    return {
-      dataSize: result.data.length,
-      dataStream: new import_readable_stream.Readable({
-        read() {
-          this.push(Buffer.from(result.data));
-          this.push(null);
-        }
-      })
-    };
-  }
-  async put(tenant, recordId, dataCid, dataStream) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `put`.");
-    }
-    const bytes = await import_dwn_sdk_js.DataStream.toBytes(dataStream);
-    const data = Buffer.from(bytes);
-    await this.#db.insertInto("dataStore").values({ tenant, recordId, dataCid, data }).executeTakeFirstOrThrow();
-    return {
-      dataSize: bytes.length
-    };
-  }
-  async delete(tenant, recordId, dataCid) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `delete`.");
-    }
-    await this.#db.deleteFrom("dataStore").where("tenant", "=", tenant).where("recordId", "=", recordId).where("dataCid", "=", dataCid).execute();
-  }
-  async clear() {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `clear`.");
-    }
-    await this.#db.deleteFrom("dataStore").execute();
-  }
-};
-
-// dist/esm/src/utils/filter.js
-var import_kysely5 = require("kysely");
-
-// dist/esm/src/utils/sanitize.js
-function extractTagsAndSanitizeIndexes(records) {
-  const tags = {};
-  const indexes = { ...records };
-  sanitizeIndexes(indexes);
-  for (let key in indexes) {
-    if (key.startsWith("tag.")) {
-      let value = indexes[key];
-      delete indexes[key];
-      tags[key.slice(4)] = value;
-    }
-  }
-  return { tags, indexes };
-}
-function sanitizeIndexes(records) {
-  for (let key in records) {
-    let value = records[key];
-    if (Array.isArray(value)) {
-      const sanitizedValues = [];
-      for (const valueItem of value) {
-        sanitizedValues.push(sanitizedValue(valueItem));
-      }
-      records[key] = sanitizedValues;
-      continue;
-    }
-    records[key] = sanitizedValue(value);
-  }
-}
-function sanitizedValue(value) {
-  switch (typeof value) {
-    case "boolean":
-      return value ? 1 : 0;
-    default:
-      return value;
-  }
-}
-function sanitizeFiltersAndSeparateTags(filters) {
-  const extractedFilters = [];
-  for (const filter of filters) {
-    const tagFilter = {};
-    const nonTagFilter = {};
-    for (let key in filter) {
-      const value = sanitizeFilterValue(filter[key]);
-      if (key.startsWith("tag.")) {
-        tagFilter[key.slice(4)] = value;
-      } else {
-        nonTagFilter[key] = value;
-      }
-    }
-    extractedFilters.push({
-      tags: tagFilter,
-      filter: nonTagFilter
-    });
-  }
-  return extractedFilters;
-}
-function sanitizeFilterValue(value) {
-  switch (typeof value) {
-    case "boolean":
-      return value ? 1 : 0;
-    default:
-      return value;
-  }
-}
-
-// dist/esm/src/utils/filter.js
-function filterSelectQuery(filters, query) {
-  const sanitizedFilters = sanitizeFiltersAndSeparateTags(filters);
-  return query.where((eb) => (
-    // evaluate the filters as an OR expression.
-    eb.or(sanitizedFilters.map(({ filter, tags }) => {
-      const andOperands = [];
-      processFilter(eb, andOperands, filter);
-      processTags(eb, andOperands, tags);
-      return eb.and(andOperands);
-    }))
-  ));
-}
-function processFilter(eb, andOperands, filter) {
-  for (let property in filter) {
-    const value = filter[property];
-    const column = new import_kysely5.DynamicModule().ref(property);
-    if (Array.isArray(value)) {
-      andOperands.push(eb(column, "in", value));
-    } else if (typeof value === "object") {
-      if (value.gt) {
-        andOperands.push(eb(column, ">", sanitizedValue(value.gt)));
-      }
-      if (value.gte) {
-        andOperands.push(eb(column, ">=", sanitizedValue(value.gte)));
-      }
-      if (value.lt) {
-        andOperands.push(eb(column, "<", sanitizedValue(value.lt)));
-      }
-      if (value.lte) {
-        andOperands.push(eb(column, "<=", sanitizedValue(value.lte)));
-      }
-    } else {
-      andOperands.push(eb(column, "=", sanitizedValue(value)));
-    }
-  }
-}
-function processTags(eb, andOperands, tags) {
-  const tagColumn = new import_kysely5.DynamicModule().ref("tag");
-  const valueNumber = new import_kysely5.DynamicModule().ref("valueNumber");
-  const valueString = new import_kysely5.DynamicModule().ref("valueString");
-  for (let property in tags) {
-    andOperands.push(eb(tagColumn, "=", property));
-    const value = tags[property];
-    if (Array.isArray(value)) {
-      if (value.some((val) => typeof val === "number")) {
-        andOperands.push(eb(valueNumber, "in", value));
-      } else {
-        andOperands.push(eb(valueString, "in", value.map((v) => String(v))));
-      }
-    } else if (typeof value === "object") {
-      if (value.gt) {
-        if (typeof value.gt === "number") {
-          andOperands.push(eb(valueNumber, ">", value.gt));
-        } else {
-          andOperands.push(eb(valueString, ">", String(value.gt)));
-        }
-      }
-      if (value.gte) {
-        if (typeof value.gte === "number") {
-          andOperands.push(eb(valueNumber, ">=", value.gte));
-        } else {
-          andOperands.push(eb(valueString, ">=", String(value.gte)));
-        }
-      }
-      if (value.lt) {
-        if (typeof value.lt === "number") {
-          andOperands.push(eb(valueNumber, "<", value.lt));
-        } else {
-          andOperands.push(eb(valueString, "<", String(value.lt)));
-        }
-      }
-      if (value.lte) {
-        if (typeof value.lte === "number") {
-          andOperands.push(eb(valueNumber, "<=", value.lte));
-        } else {
-          andOperands.push(eb(valueString, "<=", String(value.lte)));
-        }
-      }
-    } else {
-      if (typeof value === "number") {
-        andOperands.push(eb(valueNumber, "=", value));
-      } else {
-        andOperands.push(eb(valueString, "=", String(value)));
-      }
-    }
-  }
-}
-
-// dist/esm/src/event-log-sql.js
-var import_kysely6 = require("kysely");
-
-// dist/esm/src/utils/transaction.js
-async function executeWithRetryIfDatabaseIsLocked(database, operation) {
-  let retryCount = 0;
-  let success = false;
-  while (!success) {
-    try {
-      await database.transaction().execute(operation);
-      success = true;
-    } catch (error) {
-      if (error.code === "SQLITE_BUSY") {
-        retryCount++;
-        console.log(`Database is locked when attempting SQL operation, retrying #${retryCount}...`);
-      } else {
-        throw error;
-      }
-    }
-  }
-}
-
-// dist/esm/src/utils/tags.js
-var TagTables = class {
-  dialect;
-  table;
-  /**
-   * @param dialect the target dialect, necessary for returning the `insertId`
-   * @param table the DB Table in order to index the tags and values in the correct tables. Choice between `messageStoreMessages` and `eventLogMessages`
-   */
-  constructor(dialect, table) {
-    this.dialect = dialect;
-    this.table = table;
-  }
-  /**
-   * Inserts the given tags associated with the given foreign `insertId`.
-   */
-  async executeTagsInsert(foreignInsertId, tags, tx) {
-    const tagTable = this.table === "messageStoreMessages" ? "messageStoreRecordsTags" : "eventLogRecordsTags";
-    const foreignKeyReference = tagTable === "messageStoreRecordsTags" ? { messageInsertId: foreignInsertId } : { eventWatermark: foreignInsertId };
-    for (const tag in tags) {
-      const tagValues = tags[tag];
-      const values = Array.isArray(tagValues) ? tagValues : [tagValues];
-      for (const value of values) {
-        const tagInsertValue = sanitizedValue(value);
-        const insertValues = {
-          tag,
-          valueNumber: typeof tagInsertValue === "number" ? tagInsertValue : null,
-          valueString: typeof tagInsertValue === "string" ? tagInsertValue : null,
-          ...foreignKeyReference
-        };
-        await this.dialect.insertThenReturnId(tx, tagTable, insertValues, "id as insertId").executeTakeFirstOrThrow();
-      }
-    }
-  }
-};
-
-// dist/esm/src/event-log-sql.js
-var EventLogSql = class {
-  #dialect;
-  #db = null;
-  #tags;
-  constructor(dialect) {
-    this.#dialect = dialect;
-    this.#tags = new TagTables(dialect, "eventLogMessages");
-  }
-  async open() {
-    if (this.#db) {
-      return;
-    }
-    this.#db = new import_kysely6.Kysely({ dialect: this.#dialect });
-    let createTable = this.#db.schema.createTable("eventLogMessages").ifNotExists().addColumn("tenant", "varchar(255)", (col) => col.notNull()).addColumn("messageCid", "varchar(60)", (col) => col.notNull()).addColumn("interface", "varchar(20)").addColumn("method", "varchar(20)").addColumn("recordId", "varchar(60)").addColumn("entryId", "varchar(60)").addColumn("parentId", "varchar(60)").addColumn("protocol", "varchar(200)").addColumn("protocolPath", "varchar(200)").addColumn("contextId", "varchar(500)").addColumn("schema", "varchar(200)").addColumn("author", "varchar(255)").addColumn("recipient", "varchar(255)").addColumn("messageTimestamp", "varchar(30)").addColumn("dateCreated", "varchar(30)").addColumn("datePublished", "varchar(30)").addColumn("isLatestBaseState", "boolean").addColumn("published", "boolean").addColumn("prune", "boolean").addColumn("dataFormat", "varchar(30)").addColumn("dataCid", "varchar(60)").addColumn("dataSize", "integer").addColumn("attester", "text").addColumn("permissionGrantId", "varchar(60)").addColumn("latest", "text");
-    let createRecordsTagsTable = this.#db.schema.createTable("eventLogRecordsTags").ifNotExists().addColumn("tag", "text", (col) => col.notNull()).addColumn("valueString", "text").addColumn("valueNumber", "decimal");
-    createTable = this.#dialect.addAutoIncrementingColumn(createTable, "watermark", (col) => col.primaryKey());
-    createRecordsTagsTable = this.#dialect.addAutoIncrementingColumn(createRecordsTagsTable, "id", (col) => col.primaryKey());
-    createRecordsTagsTable = this.#dialect.addReferencedColumn(createRecordsTagsTable, "eventLogRecordsTags", "eventWatermark", "integer", "eventLogMessages", "watermark", "cascade");
-    await createTable.execute();
-    await createRecordsTagsTable.execute();
-  }
-  async close() {
-    await this.#db?.destroy();
-    this.#db = null;
-  }
-  async append(tenant, messageCid, indexes) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `append`.");
-    }
-    const putEventOperation = this.constructPutEventOperation({ tenant, messageCid, indexes });
-    await executeWithRetryIfDatabaseIsLocked(this.#db, putEventOperation);
-  }
-  /**
-   * Constructs a transactional operation to insert an event into the database.
-   */
-  constructPutEventOperation(queryOptions) {
-    const { tenant, messageCid, indexes } = queryOptions;
-    const { indexes: appendIndexes, tags } = extractTagsAndSanitizeIndexes(indexes);
-    return async (tx) => {
-      const eventIndexValues = {
-        tenant,
-        messageCid,
-        ...appendIndexes
-      };
-      const result = await this.#dialect.insertThenReturnId(tx, "eventLogMessages", eventIndexValues, "watermark as insertId").executeTakeFirstOrThrow();
-      if (Object.keys(tags).length > 0) {
-        await this.#tags.executeTagsInsert(result.insertId, tags, tx);
-      }
-    };
-  }
-  async getEvents(tenant, cursor) {
-    return this.queryEvents(tenant, [], cursor);
-  }
-  async queryEvents(tenant, filters, cursor) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `queryEvents`.");
-    }
-    let query = this.#db.selectFrom("eventLogMessages").leftJoin("eventLogRecordsTags", "eventLogRecordsTags.eventWatermark", "eventLogMessages.watermark").select("messageCid").distinct().select("watermark").where("tenant", "=", tenant);
-    if (filters.length > 0) {
-      query = filterSelectQuery(filters, query);
-    }
-    if (cursor !== void 0) {
-      const cursorValue = cursor.value;
-      const cursorMessageCid = cursor.messageCid;
-      query = query.where(({ eb, refTuple, tuple }) => {
-        return eb(refTuple("watermark", "messageCid"), ">", tuple(cursorValue, cursorMessageCid));
-      });
-    }
-    query = query.orderBy("watermark", "asc").orderBy("messageCid", "asc");
-    const events = [];
-    let returnCursor;
-    if (this.#dialect.isStreamingSupported) {
-      for await (let { messageCid, watermark: value } of query.stream()) {
-        events.push(messageCid);
-        returnCursor = { messageCid, value };
-      }
-    } else {
-      const results = await query.execute();
-      for (let { messageCid, watermark: value } of results) {
-        events.push(messageCid);
-        returnCursor = { messageCid, value };
-      }
-    }
-    return { events, cursor: returnCursor };
-  }
-  async deleteEventsByCid(tenant, messageCids) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `deleteEventsByCid`.");
-    }
-    if (messageCids.length === 0) {
-      return;
-    }
-    await this.#db.deleteFrom("eventLogMessages").where("tenant", "=", tenant).where("messageCid", "in", messageCids).execute();
-  }
-  async clear() {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `clear`.");
-    }
-    await this.#db.deleteFrom("eventLogMessages").execute();
-  }
-};
-
-// dist/esm/src/message-store-sql.js
-var import_dwn_sdk_js2 = require("@enbox/dwn-sdk-js");
-var import_kysely7 = require("kysely");
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/vendor/varint.js
-var encode_1 = encode;
-var MSB = 128;
-var REST = 127;
-var MSBALL = ~REST;
-var INT = Math.pow(2, 31);
-function encode(num, out, offset) {
-  out = out || [];
-  offset = offset || 0;
-  var oldOffset = offset;
-  while (num >= INT) {
-    out[offset++] = num & 255 | MSB;
-    num /= 128;
-  }
-  while (num & MSBALL) {
-    out[offset++] = num & 255 | MSB;
-    num >>>= 7;
-  }
-  out[offset] = num | 0;
-  encode.bytes = offset - oldOffset + 1;
-  return out;
-}
-var decode = read;
-var MSB$1 = 128;
-var REST$1 = 127;
-function read(buf2, offset) {
-  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
-  do {
-    if (counter >= l) {
-      read.bytes = 0;
-      throw new RangeError("Could not decode varint");
-    }
-    b = buf2[counter++];
-    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
-    shift += 7;
-  } while (b >= MSB$1);
-  read.bytes = counter - offset;
-  return res;
-}
-var N1 = Math.pow(2, 7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-var length = function(value) {
-  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
-};
-var varint = {
-  encode: encode_1,
-  decode,
-  encodingLength: length
-};
-var _brrp_varint = varint;
-var varint_default = _brrp_varint;
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/varint.js
-var decode2 = (data, offset = 0) => {
-  const code2 = varint_default.decode(data, offset);
-  return [code2, varint_default.decode.bytes];
-};
-var encodeTo = (int, target, offset = 0) => {
-  varint_default.encode(int, target, offset);
-  return target;
-};
-var encodingLength = (int) => {
-  return varint_default.encodingLength(int);
-};
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/bytes.js
-var empty = new Uint8Array(0);
-var equals = (aa, bb) => {
-  if (aa === bb)
-    return true;
-  if (aa.byteLength !== bb.byteLength) {
-    return false;
-  }
-  for (let ii = 0; ii < aa.byteLength; ii++) {
-    if (aa[ii] !== bb[ii]) {
-      return false;
-    }
-  }
-  return true;
-};
-var coerce = (o) => {
-  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
-    return o;
-  if (o instanceof ArrayBuffer)
-    return new Uint8Array(o);
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
-  }
-  throw new Error("Unknown type, must be binary type");
-};
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/hashes/digest.js
-var create = (code2, digest) => {
-  const size = digest.byteLength;
-  const sizeOffset = encodingLength(code2);
-  const digestOffset = sizeOffset + encodingLength(size);
-  const bytes = new Uint8Array(digestOffset + size);
-  encodeTo(code2, bytes, 0);
-  encodeTo(size, bytes, sizeOffset);
-  bytes.set(digest, digestOffset);
-  return new Digest(code2, size, digest, bytes);
-};
-var decode3 = (multihash) => {
-  const bytes = coerce(multihash);
-  const [code2, sizeOffset] = decode2(bytes);
-  const [size, digestOffset] = decode2(bytes.subarray(sizeOffset));
-  const digest = bytes.subarray(sizeOffset + digestOffset);
-  if (digest.byteLength !== size) {
-    throw new Error("Incorrect length");
-  }
-  return new Digest(code2, size, digest, bytes);
-};
-var equals2 = (a, b) => {
-  if (a === b) {
-    return true;
-  } else {
-    const data = (
-      /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */
-      b
-    );
-    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
-  }
-};
-var Digest = class {
-  /**
-   * Creates a multihash digest.
-   *
-   * @param {Code} code
-   * @param {Size} size
-   * @param {Uint8Array} digest
-   * @param {Uint8Array} bytes
-   */
-  constructor(code2, size, digest, bytes) {
-    this.code = code2;
-    this.size = size;
-    this.digest = digest;
-    this.bytes = bytes;
-  }
-};
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/vendor/base-x.js
-function base(ALPHABET, name2) {
-  if (ALPHABET.length >= 255) {
-    throw new TypeError("Alphabet too long");
-  }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) {
-      throw new TypeError(x + " is ambiguous");
-    }
-    BASE_MAP[xc] = i;
-  }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256);
-  var iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode6(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      pbegin++;
-    }
-    var it2 = size - length2;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
-    }
-    return str;
-  }
-  function decodeUnsafe(source) {
-    if (typeof source !== "string") {
-      throw new TypeError("Expected String");
-    }
-    if (source.length === 0) {
-      return new Uint8Array();
-    }
-    var psz = 0;
-    if (source[psz] === " ") {
-      return;
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    var size = (source.length - psz) * FACTOR + 1 >>> 0;
-    var b256 = new Uint8Array(size);
-    while (source[psz]) {
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-      if (carry === 255) {
-        return;
-      }
-      var i2 = 0;
-      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      psz++;
-    }
-    if (source[psz] === " ") {
-      return;
-    }
-    var it4 = size - length2;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j2 = zeroes;
-    while (it4 !== size) {
-      vch[j2++] = b256[it4++];
-    }
-    return vch;
-  }
-  function decode8(string) {
-    var buffer2 = decodeUnsafe(string);
-    if (buffer2) {
-      return buffer2;
-    }
-    throw new Error(`Non-${name2} character`);
-  }
-  return {
-    encode: encode6,
-    decodeUnsafe,
-    decode: decode8
-  };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/bases/base.js
-var Encoder = class {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   */
-  constructor(name2, prefix, baseEncode) {
-    this.name = name2;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-  /**
-   * @param {Uint8Array} bytes
-   * @returns {API.Multibase<Prefix>}
-   */
-  encode(bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`;
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-var Decoder = class {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor(name2, prefix, baseDecode) {
-    this.name = name2;
-    this.prefix = prefix;
-    if (prefix.codePointAt(0) === void 0) {
-      throw new Error("Invalid prefix character");
-    }
-    this.prefixCodePoint = /** @type {number} */
-    prefix.codePointAt(0);
-    this.baseDecode = baseDecode;
-  }
-  /**
-   * @param {string} text
-   */
-  decode(text) {
-    if (typeof text === "string") {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-      }
-      return this.baseDecode(text.slice(this.prefix.length));
-    } else {
-      throw Error("Can only multibase decode strings");
-    }
-  }
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or(decoder) {
-    return or(this, decoder);
-  }
-};
-var ComposedDecoder = class {
-  /**
-   * @param {Decoders<Prefix>} decoders
-   */
-  constructor(decoders) {
-    this.decoders = decoders;
-  }
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or(decoder) {
-    return or(this, decoder);
-  }
-  /**
-   * @param {string} input
-   * @returns {Uint8Array}
-   */
-  decode(input) {
-    const prefix = (
-      /** @type {Prefix} */
-      input[0]
-    );
-    const decoder = this.decoders[prefix];
-    if (decoder) {
-      return decoder.decode(input);
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-    }
-  }
-};
-var or = (left, right) => new ComposedDecoder(
-  /** @type {Decoders<L|R>} */
-  {
-    ...left.decoders || { [
-      /** @type API.UnibaseDecoder<L> */
-      left.prefix
-    ]: left },
-    ...right.decoders || { [
-      /** @type API.UnibaseDecoder<R> */
-      right.prefix
-    ]: right }
-  }
-);
-var Codec = class {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor(name2, prefix, baseEncode, baseDecode) {
-    this.name = name2;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name2, prefix, baseEncode);
-    this.decoder = new Decoder(name2, prefix, baseDecode);
-  }
-  /**
-   * @param {Uint8Array} input
-   */
-  encode(input) {
-    return this.encoder.encode(input);
-  }
-  /**
-   * @param {string} input
-   */
-  decode(input) {
-    return this.decoder.decode(input);
-  }
-};
-var from = ({ name: name2, prefix, encode: encode6, decode: decode8 }) => new Codec(name2, prefix, encode6, decode8);
-var baseX = ({ prefix, name: name2, alphabet }) => {
-  const { encode: encode6, decode: decode8 } = base_x_default(alphabet, name2);
-  return from({
-    prefix,
-    name: name2,
-    encode: encode6,
-    /**
-     * @param {string} text
-     */
-    decode: (text) => coerce(decode8(text))
-  });
-};
-var decode4 = (string, alphabet, bitsPerChar, name2) => {
-  const codes = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    codes[alphabet[i]] = i;
-  }
-  let end = string.length;
-  while (string[end - 1] === "=") {
-    --end;
-  }
-  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-  let bits = 0;
-  let buffer2 = 0;
-  let written = 0;
-  for (let i = 0; i < end; ++i) {
-    const value = codes[string[i]];
-    if (value === void 0) {
-      throw new SyntaxError(`Non-${name2} character`);
-    }
-    buffer2 = buffer2 << bitsPerChar | value;
-    bits += bitsPerChar;
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 255 & buffer2 >> bits;
-    }
-  }
-  if (bits >= bitsPerChar || 255 & buffer2 << 8 - bits) {
-    throw new SyntaxError("Unexpected end of data");
-  }
-  return out;
-};
-var encode2 = (data, alphabet, bitsPerChar) => {
-  const pad = alphabet[alphabet.length - 1] === "=";
-  const mask = (1 << bitsPerChar) - 1;
-  let out = "";
-  let bits = 0;
-  let buffer2 = 0;
-  for (let i = 0; i < data.length; ++i) {
-    buffer2 = buffer2 << 8 | data[i];
-    bits += 8;
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & buffer2 >> bits];
-    }
-  }
-  if (bits) {
-    out += alphabet[mask & buffer2 << bitsPerChar - bits];
-  }
-  if (pad) {
-    while (out.length * bitsPerChar & 7) {
-      out += "=";
-    }
-  }
-  return out;
-};
-var rfc4648 = ({ name: name2, prefix, bitsPerChar, alphabet }) => {
-  return from({
-    prefix,
-    name: name2,
-    encode(input) {
-      return encode2(input, alphabet, bitsPerChar);
-    },
-    decode(input) {
-      return decode4(input, alphabet, bitsPerChar, name2);
-    }
-  });
-};
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/bases/base58.js
-var base58btc = baseX({
-  name: "base58btc",
-  prefix: "z",
-  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-});
-var base58flickr = baseX({
-  name: "base58flickr",
-  prefix: "Z",
-  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-});
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/bases/base32.js
-var base32 = rfc4648({
-  prefix: "b",
-  name: "base32",
-  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
-  bitsPerChar: 5
-});
-var base32upper = rfc4648({
-  prefix: "B",
-  name: "base32upper",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
-  bitsPerChar: 5
-});
-var base32pad = rfc4648({
-  prefix: "c",
-  name: "base32pad",
-  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
-  bitsPerChar: 5
-});
-var base32padupper = rfc4648({
-  prefix: "C",
-  name: "base32padupper",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
-  bitsPerChar: 5
-});
-var base32hex = rfc4648({
-  prefix: "v",
-  name: "base32hex",
-  alphabet: "0123456789abcdefghijklmnopqrstuv",
-  bitsPerChar: 5
-});
-var base32hexupper = rfc4648({
-  prefix: "V",
-  name: "base32hexupper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
-  bitsPerChar: 5
-});
-var base32hexpad = rfc4648({
-  prefix: "t",
-  name: "base32hexpad",
-  alphabet: "0123456789abcdefghijklmnopqrstuv=",
-  bitsPerChar: 5
-});
-var base32hexpadupper = rfc4648({
-  prefix: "T",
-  name: "base32hexpadupper",
-  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
-  bitsPerChar: 5
-});
-var base32z = rfc4648({
-  prefix: "h",
-  name: "base32z",
-  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
-  bitsPerChar: 5
-});
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/cid.js
-var format = (link, base2) => {
-  const { bytes, version } = link;
-  switch (version) {
-    case 0:
-      return toStringV0(
-        bytes,
-        baseCache(link),
-        /** @type {API.MultibaseEncoder<"z">} */
-        base2 || base58btc.encoder
-      );
-    default:
-      return toStringV1(
-        bytes,
-        baseCache(link),
-        /** @type {API.MultibaseEncoder<Prefix>} */
-        base2 || base32.encoder
-      );
-  }
-};
-var cache = /* @__PURE__ */ new WeakMap();
-var baseCache = (cid) => {
-  const baseCache2 = cache.get(cid);
-  if (baseCache2 == null) {
-    const baseCache3 = /* @__PURE__ */ new Map();
-    cache.set(cid, baseCache3);
-    return baseCache3;
-  }
-  return baseCache2;
-};
-var CID = class _CID {
-  /**
-   * @param {Version} version - Version of the CID
-   * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param {API.MultihashDigest<Alg>} multihash - (Multi)hash of the of the content.
-   * @param {Uint8Array} bytes
-   *
-   */
-  constructor(version, code2, multihash, bytes) {
-    this.code = code2;
-    this.version = version;
-    this.multihash = multihash;
-    this.bytes = bytes;
-    this["/"] = bytes;
-  }
-  /**
-   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
-   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
-   *
-   * @deprecated
-   */
-  get asCID() {
-    return this;
-  }
-  // ArrayBufferView
-  get byteOffset() {
-    return this.bytes.byteOffset;
-  }
-  // ArrayBufferView
-  get byteLength() {
-    return this.bytes.byteLength;
-  }
-  /**
-   * @returns {CID<Data, API.DAG_PB, API.SHA_256, 0>}
-   */
-  toV0() {
-    switch (this.version) {
-      case 0: {
-        return (
-          /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-          this
-        );
-      }
-      case 1: {
-        const { code: code2, multihash } = this;
-        if (code2 !== DAG_PB_CODE) {
-          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
-        }
-        if (multihash.code !== SHA_256_CODE) {
-          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
-        }
-        return (
-          /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
-          _CID.createV0(
-            /** @type {API.MultihashDigest<API.SHA_256>} */
-            multihash
-          )
-        );
-      }
-      default: {
-        throw Error(
-          `Can not convert CID version ${this.version} to version 0. This is a bug please report`
-        );
-      }
-    }
-  }
-  /**
-   * @returns {CID<Data, Format, Alg, 1>}
-   */
-  toV1() {
-    switch (this.version) {
-      case 0: {
-        const { code: code2, digest } = this.multihash;
-        const multihash = create(code2, digest);
-        return (
-          /** @type {CID<Data, Format, Alg, 1>} */
-          _CID.createV1(this.code, multihash)
-        );
-      }
-      case 1: {
-        return (
-          /** @type {CID<Data, Format, Alg, 1>} */
-          this
-        );
-      }
-      default: {
-        throw Error(
-          `Can not convert CID version ${this.version} to version 1. This is a bug please report`
-        );
-      }
-    }
-  }
-  /**
-   * @param {unknown} other
-   * @returns {other is CID<Data, Format, Alg, Version>}
-   */
-  equals(other) {
-    return _CID.equals(this, other);
-  }
-  /**
-   * @template {unknown} Data
-   * @template {number} Format
-   * @template {number} Alg
-   * @template {API.Version} Version
-   * @param {API.Link<Data, Format, Alg, Version>} self
-   * @param {unknown} other
-   * @returns {other is CID}
-   */
-  static equals(self, other) {
-    const unknown = (
-      /** @type {{code?:unknown, version?:unknown, multihash?:unknown}} */
-      other
-    );
-    return unknown && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
-  }
-  /**
-   * @param {API.MultibaseEncoder<string>} [base]
-   * @returns {string}
-   */
-  toString(base2) {
-    return format(this, base2);
-  }
-  toJSON() {
-    return { "/": format(this) };
-  }
-  link() {
-    return this;
-  }
-  get [Symbol.toStringTag]() {
-    return "CID";
-  }
-  // Legacy
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return `CID(${this.toString()})`;
-  }
-  /**
-   * Takes any input `value` and returns a `CID` instance if it was
-   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-   * it will return value back. If `value` is not instance of this CID
-   * class, but is compatible CID it will return new instance of this
-   * `CID` class. Otherwise returns null.
-   *
-   * This allows two different incompatible versions of CID library to
-   * co-exist and interop as long as binary interface is compatible.
-   *
-   * @template {unknown} Data
-   * @template {number} Format
-   * @template {number} Alg
-   * @template {API.Version} Version
-   * @template {unknown} U
-   * @param {API.Link<Data, Format, Alg, Version>|U} input
-   * @returns {CID<Data, Format, Alg, Version>|null}
-   */
-  static asCID(input) {
-    if (input == null) {
-      return null;
-    }
-    const value = (
-      /** @type {any} */
-      input
-    );
-    if (value instanceof _CID) {
-      return value;
-    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
-      const { version, code: code2, multihash, bytes } = value;
-      return new _CID(
-        version,
-        code2,
-        /** @type {API.MultihashDigest<Alg>} */
-        multihash,
-        bytes || encodeCID(version, code2, multihash.bytes)
-      );
-    } else if (value[cidSymbol] === true) {
-      const { version, multihash, code: code2 } = value;
-      const digest = (
-        /** @type {API.MultihashDigest<Alg>} */
-        decode3(multihash)
-      );
-      return _CID.create(version, code2, digest);
-    } else {
-      return null;
-    }
-  }
-  /**
-   *
-   * @template {unknown} Data
-   * @template {number} Format
-   * @template {number} Alg
-   * @template {API.Version} Version
-   * @param {Version} version - Version of the CID
-   * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param {API.MultihashDigest<Alg>} digest - (Multi)hash of the of the content.
-   * @returns {CID<Data, Format, Alg, Version>}
-   */
-  static create(version, code2, digest) {
-    if (typeof code2 !== "number") {
-      throw new Error("String codecs are no longer supported");
-    }
-    if (!(digest.bytes instanceof Uint8Array)) {
-      throw new Error("Invalid digest");
-    }
-    switch (version) {
-      case 0: {
-        if (code2 !== DAG_PB_CODE) {
-          throw new Error(
-            `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`
-          );
-        } else {
-          return new _CID(version, code2, digest, digest.bytes);
-        }
-      }
-      case 1: {
-        const bytes = encodeCID(version, code2, digest.bytes);
-        return new _CID(version, code2, digest, bytes);
-      }
-      default: {
-        throw new Error("Invalid version");
-      }
-    }
-  }
-  /**
-   * Simplified version of `create` for CIDv0.
-   *
-   * @template {unknown} [T=unknown]
-   * @param {API.MultihashDigest<typeof SHA_256_CODE>} digest - Multihash.
-   * @returns {CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0>}
-   */
-  static createV0(digest) {
-    return _CID.create(0, DAG_PB_CODE, digest);
-  }
-  /**
-   * Simplified version of `create` for CIDv1.
-   *
-   * @template {unknown} Data
-   * @template {number} Code
-   * @template {number} Alg
-   * @param {Code} code - Content encoding format code.
-   * @param {API.MultihashDigest<Alg>} digest - Miltihash of the content.
-   * @returns {CID<Data, Code, Alg, 1>}
-   */
-  static createV1(code2, digest) {
-    return _CID.create(1, code2, digest);
-  }
-  /**
-   * Decoded a CID from its binary representation. The byte array must contain
-   * only the CID with no additional bytes.
-   *
-   * An error will be thrown if the bytes provided do not contain a valid
-   * binary representation of a CID.
-   *
-   * @template {unknown} Data
-   * @template {number} Code
-   * @template {number} Alg
-   * @template {API.Version} Ver
-   * @param {API.ByteView<API.Link<Data, Code, Alg, Ver>>} bytes
-   * @returns {CID<Data, Code, Alg, Ver>}
-   */
-  static decode(bytes) {
-    const [cid, remainder] = _CID.decodeFirst(bytes);
-    if (remainder.length) {
-      throw new Error("Incorrect length");
-    }
-    return cid;
-  }
-  /**
-   * Decoded a CID from its binary representation at the beginning of a byte
-   * array.
-   *
-   * Returns an array with the first element containing the CID and the second
-   * element containing the remainder of the original byte array. The remainder
-   * will be a zero-length byte array if the provided bytes only contained a
-   * binary CID representation.
-   *
-   * @template {unknown} T
-   * @template {number} C
-   * @template {number} A
-   * @template {API.Version} V
-   * @param {API.ByteView<API.Link<T, C, A, V>>} bytes
-   * @returns {[CID<T, C, A, V>, Uint8Array]}
-   */
-  static decodeFirst(bytes) {
-    const specs = _CID.inspectBytes(bytes);
-    const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(
-      bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
-    );
-    if (multihashBytes.byteLength !== specs.multihashSize) {
-      throw new Error("Incorrect length");
-    }
-    const digestBytes = multihashBytes.subarray(
-      specs.multihashSize - specs.digestSize
-    );
-    const digest = new Digest(
-      specs.multihashCode,
-      specs.digestSize,
-      digestBytes,
-      multihashBytes
-    );
-    const cid = specs.version === 0 ? _CID.createV0(
-      /** @type {API.MultihashDigest<API.SHA_256>} */
-      digest
-    ) : _CID.createV1(specs.codec, digest);
-    return [
-      /** @type {CID<T, C, A, V>} */
-      cid,
-      bytes.subarray(specs.size)
-    ];
-  }
-  /**
-   * Inspect the initial bytes of a CID to determine its properties.
-   *
-   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-   * bytes but for larger multicodec code values and larger multihash digest
-   * lengths these varints can be quite large. It is recommended that at least
-   * 10 bytes be made available in the `initialBytes` argument for a complete
-   * inspection.
-   *
-   * @template {unknown} T
-   * @template {number} C
-   * @template {number} A
-   * @template {API.Version} V
-   * @param {API.ByteView<API.Link<T, C, A, V>>} initialBytes
-   * @returns {{ version:V, codec:C, multihashCode:A, digestSize:number, multihashSize:number, size:number }}
-   */
-  static inspectBytes(initialBytes) {
-    let offset = 0;
-    const next = () => {
-      const [i, length2] = decode2(initialBytes.subarray(offset));
-      offset += length2;
-      return i;
-    };
-    let version = (
-      /** @type {V} */
-      next()
-    );
-    let codec = (
-      /** @type {C} */
-      DAG_PB_CODE
-    );
-    if (
-      /** @type {number} */
-      version === 18
-    ) {
-      version = /** @type {V} */
-      0;
-      offset = 0;
-    } else {
-      codec = /** @type {C} */
-      next();
-    }
-    if (version !== 0 && version !== 1) {
-      throw new RangeError(`Invalid CID version ${version}`);
-    }
-    const prefixSize = offset;
-    const multihashCode = (
-      /** @type {A} */
-      next()
-    );
-    const digestSize = next();
-    const size = offset + digestSize;
-    const multihashSize = size - prefixSize;
-    return { version, codec, multihashCode, digestSize, multihashSize, size };
-  }
-  /**
-   * Takes cid in a string representation and creates an instance. If `base`
-   * decoder is not provided will use a default from the configuration. It will
-   * throw an error if encoding of the CID is not compatible with supplied (or
-   * a default decoder).
-   *
-   * @template {string} Prefix
-   * @template {unknown} Data
-   * @template {number} Code
-   * @template {number} Alg
-   * @template {API.Version} Ver
-   * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
-   * @param {API.MultibaseDecoder<Prefix>} [base]
-   * @returns {CID<Data, Code, Alg, Ver>}
-   */
-  static parse(source, base2) {
-    const [prefix, bytes] = parseCIDtoBytes(source, base2);
-    const cid = _CID.decode(bytes);
-    if (cid.version === 0 && source[0] !== "Q") {
-      throw Error("Version 0 CID string must not include multibase prefix");
-    }
-    baseCache(cid).set(prefix, source);
-    return cid;
-  }
-};
-var parseCIDtoBytes = (source, base2) => {
-  switch (source[0]) {
-    case "Q": {
-      const decoder = base2 || base58btc;
-      return [
-        /** @type {Prefix} */
-        base58btc.prefix,
-        decoder.decode(`${base58btc.prefix}${source}`)
-      ];
-    }
-    case base58btc.prefix: {
-      const decoder = base2 || base58btc;
-      return [
-        /** @type {Prefix} */
-        base58btc.prefix,
-        decoder.decode(source)
-      ];
-    }
-    case base32.prefix: {
-      const decoder = base2 || base32;
-      return [
-        /** @type {Prefix} */
-        base32.prefix,
-        decoder.decode(source)
-      ];
-    }
-    default: {
-      if (base2 == null) {
-        throw Error(
-          "To parse non base32 or base58btc encoded CID multibase decoder must be provided"
-        );
-      }
-      return [
-        /** @type {Prefix} */
-        source[0],
-        base2.decode(source)
-      ];
-    }
-  }
-};
-var toStringV0 = (bytes, cache2, base2) => {
-  const { prefix } = base2;
-  if (prefix !== base58btc.prefix) {
-    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
-  }
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes).slice(1);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var toStringV1 = (bytes, cache2, base2) => {
-  const { prefix } = base2;
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base2.encode(bytes);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var DAG_PB_CODE = 112;
-var SHA_256_CODE = 18;
-var encodeCID = (version, code2, multihash) => {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code2);
-  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes, 0);
-  encodeTo(code2, bytes, codeOffset);
-  bytes.set(multihash, hashOffset);
-  return bytes;
-};
-var cidSymbol = Symbol.for("@ipld/js-cid/CID");
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/hashes/hasher.js
-var from2 = ({ name: name2, code: code2, encode: encode6 }) => new Hasher(name2, code2, encode6);
-var Hasher = class {
-  /**
-   *
-   * @param {Name} name
-   * @param {Code} code
-   * @param {(input: Uint8Array) => Await<Uint8Array>} encode
-   */
-  constructor(name2, code2, encode6) {
-    this.name = name2;
-    this.code = code2;
-    this.encode = encode6;
-  }
-  /**
-   * @param {Uint8Array} input
-   * @returns {Await<Digest.Digest<Code, number>>}
-   */
-  digest(input) {
-    if (input instanceof Uint8Array) {
-      const result = this.encode(input);
-      return result instanceof Uint8Array ? create(this.code, result) : result.then((digest) => create(this.code, digest));
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/block.js
-function readonly({ enumerable = true, configurable = false } = {}) {
-  return { enumerable, configurable, writable: false };
-}
-function* linksWithin(path, value) {
-  if (value != null && typeof value === "object") {
-    if (Array.isArray(value)) {
-      for (const [index, element] of value.entries()) {
-        const elementPath = [...path, index];
-        const cid = CID.asCID(element);
-        if (cid) {
-          yield [elementPath.join("/"), cid];
-        } else if (typeof element === "object") {
-          yield* links(element, elementPath);
-        }
-      }
-    } else {
-      const cid = CID.asCID(value);
-      if (cid) {
-        yield [path.join("/"), cid];
-      } else {
-        yield* links(value, path);
-      }
-    }
-  }
-}
-function* links(source, base2) {
-  if (source == null || source instanceof Uint8Array) {
-    return;
-  }
-  const cid = CID.asCID(source);
-  if (cid) {
-    yield [base2.join("/"), cid];
-  }
-  for (const [key, value] of Object.entries(source)) {
-    const path = (
-      /** @type {[string|number, string]} */
-      [...base2, key]
-    );
-    yield* linksWithin(path, value);
-  }
-}
-function* treeWithin(path, value) {
-  if (Array.isArray(value)) {
-    for (const [index, element] of value.entries()) {
-      const elementPath = [...path, index];
-      yield elementPath.join("/");
-      if (typeof element === "object" && !CID.asCID(element)) {
-        yield* tree(element, elementPath);
-      }
-    }
-  } else {
-    yield* tree(value, path);
-  }
-}
-function* tree(source, base2) {
-  if (source == null || typeof source !== "object") {
-    return;
-  }
-  for (const [key, value] of Object.entries(source)) {
-    const path = (
-      /** @type {[string|number, string]} */
-      [...base2, key]
-    );
-    yield path.join("/");
-    if (value != null && !(value instanceof Uint8Array) && typeof value === "object" && !CID.asCID(value)) {
-      yield* treeWithin(path, value);
-    }
-  }
-}
-function get(source, path) {
-  let node = (
-    /** @type {Record<string, any>} */
-    source
-  );
-  for (const [index, key] of path.entries()) {
-    node = node[key];
-    if (node == null) {
-      throw new Error(`Object has no property at ${path.slice(0, index + 1).map((part) => `[${JSON.stringify(part)}]`).join("")}`);
-    }
-    const cid = CID.asCID(node);
-    if (cid) {
-      return { value: cid, remaining: path.slice(index + 1).join("/") };
-    }
-  }
-  return { value: node };
-}
-var Block = class {
-  /**
-   * @param {object} options
-   * @param {CID<T, C, A, V>} options.cid
-   * @param {API.ByteView<T>} options.bytes
-   * @param {T} options.value
-   */
-  constructor({ cid, bytes, value }) {
-    if (!cid || !bytes || typeof value === "undefined") {
-      throw new Error("Missing required argument");
-    }
-    this.cid = cid;
-    this.bytes = bytes;
-    this.value = value;
-    this.asBlock = this;
-    Object.defineProperties(this, {
-      cid: readonly(),
-      bytes: readonly(),
-      value: readonly(),
-      asBlock: readonly()
-    });
-  }
-  links() {
-    return links(this.value, []);
-  }
-  tree() {
-    return tree(this.value, []);
-  }
-  /**
-   *
-   * @param {string} [path]
-   * @returns {API.BlockCursorView<unknown>}
-   */
-  get(path = "/") {
-    return get(this.value, path.split("/").filter(Boolean));
-  }
-};
-async function encode3({ value, codec, hasher }) {
-  if (typeof value === "undefined")
-    throw new Error('Missing required argument "value"');
-  if (!codec || !hasher)
-    throw new Error("Missing required argument: codec or hasher");
-  const bytes = codec.encode(value);
-  const hash = await hasher.digest(bytes);
-  const cid = CID.create(
-    1,
-    codec.code,
-    hash
-  );
-  return new Block({ value, bytes, cid });
-}
-async function decode5({ bytes, codec, hasher }) {
-  if (!bytes)
-    throw new Error('Missing required argument "bytes"');
-  if (!codec || !hasher)
-    throw new Error("Missing required argument: codec or hasher");
-  const value = codec.decode(bytes);
-  const hash = await hasher.digest(bytes);
-  const cid = CID.create(1, codec.code, hash);
-  return new Block({ value, bytes, cid });
-}
-
-// ../../node_modules/.pnpm/@ipld+dag-cbor@9.0.5/node_modules/@ipld/dag-cbor/src/index.js
-var src_exports = {};
-__export(src_exports, {
-  code: () => code,
-  decode: () => decode7,
-  encode: () => encode5,
-  name: () => name
-});
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/is.js
-var typeofs = [
-  "string",
-  "number",
-  "bigint",
-  "symbol"
-];
-var objectTypeNames = [
-  "Function",
-  "Generator",
-  "AsyncGenerator",
-  "GeneratorFunction",
-  "AsyncGeneratorFunction",
-  "AsyncFunction",
-  "Observable",
-  "Array",
-  "Buffer",
-  "Object",
-  "RegExp",
-  "Date",
-  "Error",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "ArrayBuffer",
-  "SharedArrayBuffer",
-  "DataView",
-  "Promise",
-  "URL",
-  "HTMLElement",
-  "Int8Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Int16Array",
-  "Uint16Array",
-  "Int32Array",
-  "Uint32Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array"
-];
-function is(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (value === true || value === false) {
-    return "boolean";
-  }
-  const typeOf = typeof value;
-  if (typeofs.includes(typeOf)) {
-    return typeOf;
-  }
-  if (typeOf === "function") {
-    return "Function";
-  }
-  if (Array.isArray(value)) {
-    return "Array";
-  }
-  if (isBuffer(value)) {
-    return "Buffer";
-  }
-  const objectType = getObjectType(value);
-  if (objectType) {
-    return objectType;
-  }
-  return "Object";
-}
-function isBuffer(value) {
-  return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value);
-}
-function getObjectType(value) {
-  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-  if (objectTypeNames.includes(objectTypeName)) {
-    return objectTypeName;
-  }
-  return void 0;
-}
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/token.js
-var Type = class {
-  /**
-   * @param {number} major
-   * @param {string} name
-   * @param {boolean} terminal
-   */
-  constructor(major, name2, terminal) {
-    this.major = major;
-    this.majorEncoded = major << 5;
-    this.name = name2;
-    this.terminal = terminal;
-  }
-  /* c8 ignore next 3 */
-  toString() {
-    return `Type[${this.major}].${this.name}`;
-  }
-  /**
-   * @param {Type} typ
-   * @returns {number}
-   */
-  compare(typ) {
-    return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
-  }
-};
-Type.uint = new Type(0, "uint", true);
-Type.negint = new Type(1, "negint", true);
-Type.bytes = new Type(2, "bytes", true);
-Type.string = new Type(3, "string", true);
-Type.array = new Type(4, "array", false);
-Type.map = new Type(5, "map", false);
-Type.tag = new Type(6, "tag", false);
-Type.float = new Type(7, "float", true);
-Type.false = new Type(7, "false", true);
-Type.true = new Type(7, "true", true);
-Type.null = new Type(7, "null", true);
-Type.undefined = new Type(7, "undefined", true);
-Type.break = new Type(7, "break", true);
-var Token = class {
-  /**
-   * @param {Type} type
-   * @param {any} [value]
-   * @param {number} [encodedLength]
-   */
-  constructor(type, value, encodedLength) {
-    this.type = type;
-    this.value = value;
-    this.encodedLength = encodedLength;
-    this.encodedBytes = void 0;
-    this.byteValue = void 0;
-  }
-  /* c8 ignore next 3 */
-  toString() {
-    return `Token[${this.type}].${this.value}`;
-  }
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/byte-utils.js
-var useBuffer = globalThis.process && // @ts-ignore
-!globalThis.process.browser && // @ts-ignore
-globalThis.Buffer && // @ts-ignore
-typeof globalThis.Buffer.isBuffer === "function";
-var textDecoder = new TextDecoder();
-var textEncoder = new TextEncoder();
-function isBuffer2(buf2) {
-  return useBuffer && globalThis.Buffer.isBuffer(buf2);
-}
-function asU8A(buf2) {
-  if (!(buf2 instanceof Uint8Array)) {
-    return Uint8Array.from(buf2);
-  }
-  return isBuffer2(buf2) ? new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength) : buf2;
-}
-var toString = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    return end - start > 64 ? (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(bytes.subarray(start, end)).toString("utf8")
-    ) : utf8Slice(bytes, start, end);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    return end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
-  }
-);
-var fromString = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {string} string
-   */
-  (string) => {
-    return string.length > 64 ? (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(string)
-    ) : utf8ToBytes(string);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {string} string
-   */
-  (string) => {
-    return string.length > 64 ? textEncoder.encode(string) : utf8ToBytes(string);
-  }
-);
-var fromArray = (arr) => {
-  return Uint8Array.from(arr);
-};
-var slice = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    if (isBuffer2(bytes)) {
-      return new Uint8Array(bytes.subarray(start, end));
-    }
-    return bytes.slice(start, end);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    return bytes.slice(start, end);
-  }
-);
-var concat = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array[]} chunks
-   * @param {number} length
-   * @returns {Uint8Array}
-   */
-  (chunks, length2) => {
-    chunks = chunks.map((c) => c instanceof Uint8Array ? c : (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(c)
-    ));
-    return asU8A(globalThis.Buffer.concat(chunks, length2));
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array[]} chunks
-   * @param {number} length
-   * @returns {Uint8Array}
-   */
-  (chunks, length2) => {
-    const out = new Uint8Array(length2);
-    let off = 0;
-    for (let b of chunks) {
-      if (off + b.length > out.length) {
-        b = b.subarray(0, out.length - off);
-      }
-      out.set(b, off);
-      off += b.length;
-    }
-    return out;
-  }
-);
-var alloc = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {number} size
-   * @returns {Uint8Array}
-   */
-  (size) => {
-    return globalThis.Buffer.allocUnsafe(size);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {number} size
-   * @returns {Uint8Array}
-   */
-  (size) => {
-    return new Uint8Array(size);
-  }
-);
-function compare(b1, b2) {
-  if (isBuffer2(b1) && isBuffer2(b2)) {
-    return b1.compare(b2);
-  }
-  for (let i = 0; i < b1.length; i++) {
-    if (b1[i] === b2[i]) {
-      continue;
-    }
-    return b1[i] < b2[i] ? -1 : 1;
-  }
-  return 0;
-}
-function utf8ToBytes(str) {
-  const out = [];
-  let p = 0;
-  for (let i = 0; i < str.length; i++) {
-    let c = str.charCodeAt(i);
-    if (c < 128) {
-      out[p++] = c;
-    } else if (c < 2048) {
-      out[p++] = c >> 6 | 192;
-      out[p++] = c & 63 | 128;
-    } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
-      out[p++] = c >> 18 | 240;
-      out[p++] = c >> 12 & 63 | 128;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    } else {
-      out[p++] = c >> 12 | 224;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    }
-  }
-  return out;
-}
-function utf8Slice(buf2, offset, end) {
-  const res = [];
-  while (offset < end) {
-    const firstByte = buf2[offset];
-    let codePoint = null;
-    let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-    if (offset + bytesPerSequence <= end) {
-      let secondByte, thirdByte, fourthByte, tempCodePoint;
-      switch (bytesPerSequence) {
-        case 1:
-          if (firstByte < 128) {
-            codePoint = firstByte;
-          }
-          break;
-        case 2:
-          secondByte = buf2[offset + 1];
-          if ((secondByte & 192) === 128) {
-            tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-            if (tempCodePoint > 127) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 3:
-          secondByte = buf2[offset + 1];
-          thirdByte = buf2[offset + 2];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-            if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-              codePoint = tempCodePoint;
-            }
-          }
-          break;
-        case 4:
-          secondByte = buf2[offset + 1];
-          thirdByte = buf2[offset + 2];
-          fourthByte = buf2[offset + 3];
-          if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-            tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-            if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-              codePoint = tempCodePoint;
-            }
-          }
-      }
-    }
-    if (codePoint === null) {
-      codePoint = 65533;
-      bytesPerSequence = 1;
-    } else if (codePoint > 65535) {
-      codePoint -= 65536;
-      res.push(codePoint >>> 10 & 1023 | 55296);
-      codePoint = 56320 | codePoint & 1023;
-    }
-    res.push(codePoint);
-    offset += bytesPerSequence;
-  }
-  return decodeCodePointsArray(res);
-}
-var MAX_ARGUMENTS_LENGTH = 4096;
-function decodeCodePointsArray(codePoints) {
-  const len = codePoints.length;
-  if (len <= MAX_ARGUMENTS_LENGTH) {
-    return String.fromCharCode.apply(String, codePoints);
-  }
-  let res = "";
-  let i = 0;
-  while (i < len) {
-    res += String.fromCharCode.apply(
-      String,
-      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
-    );
-  }
-  return res;
-}
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/bl.js
-var defaultChunkSize = 256;
-var Bl = class {
-  /**
-   * @param {number} [chunkSize]
-   */
-  constructor(chunkSize = defaultChunkSize) {
-    this.chunkSize = chunkSize;
-    this.cursor = 0;
-    this.maxCursor = -1;
-    this.chunks = [];
-    this._initReuseChunk = null;
-  }
-  reset() {
-    this.cursor = 0;
-    this.maxCursor = -1;
-    if (this.chunks.length) {
-      this.chunks = [];
-    }
-    if (this._initReuseChunk !== null) {
-      this.chunks.push(this._initReuseChunk);
-      this.maxCursor = this._initReuseChunk.length - 1;
-    }
-  }
-  /**
-   * @param {Uint8Array|number[]} bytes
-   */
-  push(bytes) {
-    let topChunk = this.chunks[this.chunks.length - 1];
-    const newMax = this.cursor + bytes.length;
-    if (newMax <= this.maxCursor + 1) {
-      const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-      topChunk.set(bytes, chunkPos);
-    } else {
-      if (topChunk) {
-        const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-        if (chunkPos < topChunk.length) {
-          this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
-          this.maxCursor = this.cursor - 1;
-        }
-      }
-      if (bytes.length < 64 && bytes.length < this.chunkSize) {
-        topChunk = alloc(this.chunkSize);
-        this.chunks.push(topChunk);
-        this.maxCursor += topChunk.length;
-        if (this._initReuseChunk === null) {
-          this._initReuseChunk = topChunk;
-        }
-        topChunk.set(bytes, 0);
-      } else {
-        this.chunks.push(bytes);
-        this.maxCursor += bytes.length;
-      }
-    }
-    this.cursor += bytes.length;
-  }
-  /**
-   * @param {boolean} [reset]
-   * @returns {Uint8Array}
-   */
-  toBytes(reset = false) {
-    let byts;
-    if (this.chunks.length === 1) {
-      const chunk = this.chunks[0];
-      if (reset && this.cursor > chunk.length / 2) {
-        byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
-        this._initReuseChunk = null;
-        this.chunks = [];
-      } else {
-        byts = slice(chunk, 0, this.cursor);
-      }
-    } else {
-      byts = concat(this.chunks, this.cursor);
-    }
-    if (reset) {
-      this.reset();
-    }
-    return byts;
-  }
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/common.js
-var decodeErrPrefix = "CBOR decode error:";
-var encodeErrPrefix = "CBOR encode error:";
-var uintMinorPrefixBytes = [];
-uintMinorPrefixBytes[23] = 1;
-uintMinorPrefixBytes[24] = 2;
-uintMinorPrefixBytes[25] = 3;
-uintMinorPrefixBytes[26] = 5;
-uintMinorPrefixBytes[27] = 9;
-function assertEnoughData(data, pos, need) {
-  if (data.length - pos < need) {
-    throw new Error(`${decodeErrPrefix} not enough data for type`);
-  }
-}
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/0uint.js
-var uintBoundaries = [24, 256, 65536, 4294967296, BigInt("18446744073709551616")];
-function readUint8(data, offset, options) {
-  assertEnoughData(data, offset, 1);
-  const value = data[offset];
-  if (options.strict === true && value < uintBoundaries[0]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint16(data, offset, options) {
-  assertEnoughData(data, offset, 2);
-  const value = data[offset] << 8 | data[offset + 1];
-  if (options.strict === true && value < uintBoundaries[1]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint32(data, offset, options) {
-  assertEnoughData(data, offset, 4);
-  const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  if (options.strict === true && value < uintBoundaries[2]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint64(data, offset, options) {
-  assertEnoughData(data, offset, 8);
-  const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
-  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
-  if (options.strict === true && value < uintBoundaries[3]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  if (value <= Number.MAX_SAFE_INTEGER) {
-    return Number(value);
-  }
-  if (options.allowBigInt === true) {
-    return value;
-  }
-  throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-}
-function decodeUint8(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint8(data, pos + 1, options), 2);
-}
-function decodeUint16(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint16(data, pos + 1, options), 3);
-}
-function decodeUint32(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint32(data, pos + 1, options), 5);
-}
-function decodeUint64(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
-}
-function encodeUint(buf2, token) {
-  return encodeUintValue(buf2, 0, token.value);
-}
-function encodeUintValue(buf2, major, uint) {
-  if (uint < uintBoundaries[0]) {
-    const nuint = Number(uint);
-    buf2.push([major | nuint]);
-  } else if (uint < uintBoundaries[1]) {
-    const nuint = Number(uint);
-    buf2.push([major | 24, nuint]);
-  } else if (uint < uintBoundaries[2]) {
-    const nuint = Number(uint);
-    buf2.push([major | 25, nuint >>> 8, nuint & 255]);
-  } else if (uint < uintBoundaries[3]) {
-    const nuint = Number(uint);
-    buf2.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
-  } else {
-    const buint = BigInt(uint);
-    if (buint < uintBoundaries[4]) {
-      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0];
-      let lo = Number(buint & BigInt(4294967295));
-      let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
-      set[8] = lo & 255;
-      lo = lo >> 8;
-      set[7] = lo & 255;
-      lo = lo >> 8;
-      set[6] = lo & 255;
-      lo = lo >> 8;
-      set[5] = lo & 255;
-      set[4] = hi & 255;
-      hi = hi >> 8;
-      set[3] = hi & 255;
-      hi = hi >> 8;
-      set[2] = hi & 255;
-      hi = hi >> 8;
-      set[1] = hi & 255;
-      buf2.push(set);
-    } else {
-      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
-    }
-  }
-}
-encodeUint.encodedSize = function encodedSize(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-encodeUintValue.encodedSize = function encodedSize2(uint) {
-  if (uint < uintBoundaries[0]) {
-    return 1;
-  }
-  if (uint < uintBoundaries[1]) {
-    return 2;
-  }
-  if (uint < uintBoundaries[2]) {
-    return 3;
-  }
-  if (uint < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : (
-    /* c8 ignore next */
-    0
-  );
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/1negint.js
-function decodeNegint8(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - readUint8(data, pos + 1, options), 2);
-}
-function decodeNegint16(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - readUint16(data, pos + 1, options), 3);
-}
-function decodeNegint32(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - readUint32(data, pos + 1, options), 5);
-}
-var neg1b = BigInt(-1);
-var pos1b = BigInt(1);
-function decodeNegint64(data, pos, _minor, options) {
-  const int = readUint64(data, pos + 1, options);
-  if (typeof int !== "bigint") {
-    const value = -1 - int;
-    if (value >= Number.MIN_SAFE_INTEGER) {
-      return new Token(Type.negint, value, 9);
-    }
-  }
-  if (options.allowBigInt !== true) {
-    throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-  }
-  return new Token(Type.negint, neg1b - BigInt(int), 9);
-}
-function encodeNegint(buf2, token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-  encodeUintValue(buf2, token.type.majorEncoded, unsigned);
-}
-encodeNegint.encodedSize = function encodedSize3(token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-  if (unsigned < uintBoundaries[0]) {
-    return 1;
-  }
-  if (unsigned < uintBoundaries[1]) {
-    return 2;
-  }
-  if (unsigned < uintBoundaries[2]) {
-    return 3;
-  }
-  if (unsigned < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeNegint.compareTokens = function compareTokens2(tok1, tok2) {
-  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : (
-    /* c8 ignore next */
-    0
-  );
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/2bytes.js
-function toToken(data, pos, prefix, length2) {
-  assertEnoughData(data, pos, prefix + length2);
-  const buf2 = slice(data, pos + prefix, pos + prefix + length2);
-  return new Token(Type.bytes, buf2, prefix + length2);
-}
-function decodeBytesCompact(data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor);
-}
-function decodeBytes8(data, pos, _minor, options) {
-  return toToken(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeBytes16(data, pos, _minor, options) {
-  return toToken(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeBytes32(data, pos, _minor, options) {
-  return toToken(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeBytes64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
-  }
-  return toToken(data, pos, 9, l);
-}
-function tokenBytes(token) {
-  if (token.encodedBytes === void 0) {
-    token.encodedBytes = token.type === Type.string ? fromString(token.value) : token.value;
-  }
-  return token.encodedBytes;
-}
-function encodeBytes(buf2, token) {
-  const bytes = tokenBytes(token);
-  encodeUintValue(buf2, token.type.majorEncoded, bytes.length);
-  buf2.push(bytes);
-}
-encodeBytes.encodedSize = function encodedSize4(token) {
-  const bytes = tokenBytes(token);
-  return encodeUintValue.encodedSize(bytes.length) + bytes.length;
-};
-encodeBytes.compareTokens = function compareTokens3(tok1, tok2) {
-  return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
-};
-function compareBytes(b1, b2) {
-  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
-}
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/3string.js
-function toToken2(data, pos, prefix, length2, options) {
-  const totLength = prefix + length2;
-  assertEnoughData(data, pos, totLength);
-  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength);
-  if (options.retainStringBytes === true) {
-    tok.byteValue = slice(data, pos + prefix, pos + totLength);
-  }
-  return tok;
-}
-function decodeStringCompact(data, pos, minor, options) {
-  return toToken2(data, pos, 1, minor, options);
-}
-function decodeString8(data, pos, _minor, options) {
-  return toToken2(data, pos, 2, readUint8(data, pos + 1, options), options);
-}
-function decodeString16(data, pos, _minor, options) {
-  return toToken2(data, pos, 3, readUint16(data, pos + 1, options), options);
-}
-function decodeString32(data, pos, _minor, options) {
-  return toToken2(data, pos, 5, readUint32(data, pos + 1, options), options);
-}
-function decodeString64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`);
-  }
-  return toToken2(data, pos, 9, l, options);
-}
-var encodeString = encodeBytes;
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/4array.js
-function toToken3(_data, _pos, prefix, length2) {
-  return new Token(Type.array, length2, prefix);
-}
-function decodeArrayCompact(data, pos, minor, _options) {
-  return toToken3(data, pos, 1, minor);
-}
-function decodeArray8(data, pos, _minor, options) {
-  return toToken3(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeArray16(data, pos, _minor, options) {
-  return toToken3(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeArray32(data, pos, _minor, options) {
-  return toToken3(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeArray64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`);
-  }
-  return toToken3(data, pos, 9, l);
-}
-function decodeArrayIndefinite(data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-  }
-  return toToken3(data, pos, 1, Infinity);
-}
-function encodeArray(buf2, token) {
-  encodeUintValue(buf2, Type.array.majorEncoded, token.value);
-}
-encodeArray.compareTokens = encodeUint.compareTokens;
-encodeArray.encodedSize = function encodedSize5(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/5map.js
-function toToken4(_data, _pos, prefix, length2) {
-  return new Token(Type.map, length2, prefix);
-}
-function decodeMapCompact(data, pos, minor, _options) {
-  return toToken4(data, pos, 1, minor);
-}
-function decodeMap8(data, pos, _minor, options) {
-  return toToken4(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeMap16(data, pos, _minor, options) {
-  return toToken4(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeMap32(data, pos, _minor, options) {
-  return toToken4(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeMap64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`);
-  }
-  return toToken4(data, pos, 9, l);
-}
-function decodeMapIndefinite(data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-  }
-  return toToken4(data, pos, 1, Infinity);
-}
-function encodeMap(buf2, token) {
-  encodeUintValue(buf2, Type.map.majorEncoded, token.value);
-}
-encodeMap.compareTokens = encodeUint.compareTokens;
-encodeMap.encodedSize = function encodedSize6(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/6tag.js
-function decodeTagCompact(_data, _pos, minor, _options) {
-  return new Token(Type.tag, minor, 1);
-}
-function decodeTag8(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint8(data, pos + 1, options), 2);
-}
-function decodeTag16(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint16(data, pos + 1, options), 3);
-}
-function decodeTag32(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint32(data, pos + 1, options), 5);
-}
-function decodeTag64(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
-}
-function encodeTag(buf2, token) {
-  encodeUintValue(buf2, Type.tag.majorEncoded, token.value);
-}
-encodeTag.compareTokens = encodeUint.compareTokens;
-encodeTag.encodedSize = function encodedSize7(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/7float.js
-var MINOR_FALSE = 20;
-var MINOR_TRUE = 21;
-var MINOR_NULL = 22;
-var MINOR_UNDEFINED = 23;
-function decodeUndefined(_data, _pos, _minor, options) {
-  if (options.allowUndefined === false) {
-    throw new Error(`${decodeErrPrefix} undefined values are not supported`);
-  } else if (options.coerceUndefinedToNull === true) {
-    return new Token(Type.null, null, 1);
-  }
-  return new Token(Type.undefined, void 0, 1);
-}
-function decodeBreak(_data, _pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-  }
-  return new Token(Type.break, void 0, 1);
-}
-function createToken(value, bytes, options) {
-  if (options) {
-    if (options.allowNaN === false && Number.isNaN(value)) {
-      throw new Error(`${decodeErrPrefix} NaN values are not supported`);
-    }
-    if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
-      throw new Error(`${decodeErrPrefix} Infinity values are not supported`);
-    }
-  }
-  return new Token(Type.float, value, bytes);
-}
-function decodeFloat16(data, pos, _minor, options) {
-  return createToken(readFloat16(data, pos + 1), 3, options);
-}
-function decodeFloat32(data, pos, _minor, options) {
-  return createToken(readFloat32(data, pos + 1), 5, options);
-}
-function decodeFloat64(data, pos, _minor, options) {
-  return createToken(readFloat64(data, pos + 1), 9, options);
-}
-function encodeFloat(buf2, token, options) {
-  const float = token.value;
-  if (float === false) {
-    buf2.push([Type.float.majorEncoded | MINOR_FALSE]);
-  } else if (float === true) {
-    buf2.push([Type.float.majorEncoded | MINOR_TRUE]);
-  } else if (float === null) {
-    buf2.push([Type.float.majorEncoded | MINOR_NULL]);
-  } else if (float === void 0) {
-    buf2.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
-  } else {
-    let decoded;
-    let success = false;
-    if (!options || options.float64 !== true) {
-      encodeFloat16(float);
-      decoded = readFloat16(ui8a, 1);
-      if (float === decoded || Number.isNaN(float)) {
-        ui8a[0] = 249;
-        buf2.push(ui8a.slice(0, 3));
-        success = true;
-      } else {
-        encodeFloat32(float);
-        decoded = readFloat32(ui8a, 1);
-        if (float === decoded) {
-          ui8a[0] = 250;
-          buf2.push(ui8a.slice(0, 5));
-          success = true;
-        }
-      }
-    }
-    if (!success) {
-      encodeFloat64(float);
-      decoded = readFloat64(ui8a, 1);
-      ui8a[0] = 251;
-      buf2.push(ui8a.slice(0, 9));
-    }
-  }
-}
-encodeFloat.encodedSize = function encodedSize8(token, options) {
-  const float = token.value;
-  if (float === false || float === true || float === null || float === void 0) {
-    return 1;
-  }
-  if (!options || options.float64 !== true) {
-    encodeFloat16(float);
-    let decoded = readFloat16(ui8a, 1);
-    if (float === decoded || Number.isNaN(float)) {
-      return 3;
-    }
-    encodeFloat32(float);
-    decoded = readFloat32(ui8a, 1);
-    if (float === decoded) {
-      return 5;
-    }
-  }
-  return 9;
-};
-var buffer = new ArrayBuffer(9);
-var dataView = new DataView(buffer, 1);
-var ui8a = new Uint8Array(buffer, 0);
-function encodeFloat16(inp) {
-  if (inp === Infinity) {
-    dataView.setUint16(0, 31744, false);
-  } else if (inp === -Infinity) {
-    dataView.setUint16(0, 64512, false);
-  } else if (Number.isNaN(inp)) {
-    dataView.setUint16(0, 32256, false);
-  } else {
-    dataView.setFloat32(0, inp);
-    const valu32 = dataView.getUint32(0);
-    const exponent = (valu32 & 2139095040) >> 23;
-    const mantissa = valu32 & 8388607;
-    if (exponent === 255) {
-      dataView.setUint16(0, 31744, false);
-    } else if (exponent === 0) {
-      dataView.setUint16(0, (inp & 2147483648) >> 16 | mantissa >> 13, false);
-    } else {
-      const logicalExponent = exponent - 127;
-      if (logicalExponent < -24) {
-        dataView.setUint16(0, 0);
-      } else if (logicalExponent < -14) {
-        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | /* sign bit */
-        1 << 24 + logicalExponent, false);
-      } else {
-        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
-      }
-    }
-  }
-}
-function readFloat16(ui8a2, pos) {
-  if (ui8a2.length - pos < 2) {
-    throw new Error(`${decodeErrPrefix} not enough data for float16`);
-  }
-  const half = (ui8a2[pos] << 8) + ui8a2[pos + 1];
-  if (half === 31744) {
-    return Infinity;
-  }
-  if (half === 64512) {
-    return -Infinity;
-  }
-  if (half === 32256) {
-    return NaN;
-  }
-  const exp = half >> 10 & 31;
-  const mant = half & 1023;
-  let val;
-  if (exp === 0) {
-    val = mant * 2 ** -24;
-  } else if (exp !== 31) {
-    val = (mant + 1024) * 2 ** (exp - 25);
-  } else {
-    val = mant === 0 ? Infinity : NaN;
-  }
-  return half & 32768 ? -val : val;
-}
-function encodeFloat32(inp) {
-  dataView.setFloat32(0, inp, false);
-}
-function readFloat32(ui8a2, pos) {
-  if (ui8a2.length - pos < 4) {
-    throw new Error(`${decodeErrPrefix} not enough data for float32`);
-  }
-  const offset = (ui8a2.byteOffset || 0) + pos;
-  return new DataView(ui8a2.buffer, offset, 4).getFloat32(0, false);
-}
-function encodeFloat64(inp) {
-  dataView.setFloat64(0, inp, false);
-}
-function readFloat64(ui8a2, pos) {
-  if (ui8a2.length - pos < 8) {
-    throw new Error(`${decodeErrPrefix} not enough data for float64`);
-  }
-  const offset = (ui8a2.byteOffset || 0) + pos;
-  return new DataView(ui8a2.buffer, offset, 8).getFloat64(0, false);
-}
-encodeFloat.compareTokens = encodeUint.compareTokens;
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/jump.js
-function invalidMinor(data, pos, minor) {
-  throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
-}
-function errorer(msg) {
-  return () => {
-    throw new Error(`${decodeErrPrefix} ${msg}`);
-  };
-}
-var jump = [];
-for (let i = 0; i <= 23; i++) {
-  jump[i] = invalidMinor;
-}
-jump[24] = decodeUint8;
-jump[25] = decodeUint16;
-jump[26] = decodeUint32;
-jump[27] = decodeUint64;
-jump[28] = invalidMinor;
-jump[29] = invalidMinor;
-jump[30] = invalidMinor;
-jump[31] = invalidMinor;
-for (let i = 32; i <= 55; i++) {
-  jump[i] = invalidMinor;
-}
-jump[56] = decodeNegint8;
-jump[57] = decodeNegint16;
-jump[58] = decodeNegint32;
-jump[59] = decodeNegint64;
-jump[60] = invalidMinor;
-jump[61] = invalidMinor;
-jump[62] = invalidMinor;
-jump[63] = invalidMinor;
-for (let i = 64; i <= 87; i++) {
-  jump[i] = decodeBytesCompact;
-}
-jump[88] = decodeBytes8;
-jump[89] = decodeBytes16;
-jump[90] = decodeBytes32;
-jump[91] = decodeBytes64;
-jump[92] = invalidMinor;
-jump[93] = invalidMinor;
-jump[94] = invalidMinor;
-jump[95] = errorer("indefinite length bytes/strings are not supported");
-for (let i = 96; i <= 119; i++) {
-  jump[i] = decodeStringCompact;
-}
-jump[120] = decodeString8;
-jump[121] = decodeString16;
-jump[122] = decodeString32;
-jump[123] = decodeString64;
-jump[124] = invalidMinor;
-jump[125] = invalidMinor;
-jump[126] = invalidMinor;
-jump[127] = errorer("indefinite length bytes/strings are not supported");
-for (let i = 128; i <= 151; i++) {
-  jump[i] = decodeArrayCompact;
-}
-jump[152] = decodeArray8;
-jump[153] = decodeArray16;
-jump[154] = decodeArray32;
-jump[155] = decodeArray64;
-jump[156] = invalidMinor;
-jump[157] = invalidMinor;
-jump[158] = invalidMinor;
-jump[159] = decodeArrayIndefinite;
-for (let i = 160; i <= 183; i++) {
-  jump[i] = decodeMapCompact;
-}
-jump[184] = decodeMap8;
-jump[185] = decodeMap16;
-jump[186] = decodeMap32;
-jump[187] = decodeMap64;
-jump[188] = invalidMinor;
-jump[189] = invalidMinor;
-jump[190] = invalidMinor;
-jump[191] = decodeMapIndefinite;
-for (let i = 192; i <= 215; i++) {
-  jump[i] = decodeTagCompact;
-}
-jump[216] = decodeTag8;
-jump[217] = decodeTag16;
-jump[218] = decodeTag32;
-jump[219] = decodeTag64;
-jump[220] = invalidMinor;
-jump[221] = invalidMinor;
-jump[222] = invalidMinor;
-jump[223] = invalidMinor;
-for (let i = 224; i <= 243; i++) {
-  jump[i] = errorer("simple values are not supported");
-}
-jump[244] = invalidMinor;
-jump[245] = invalidMinor;
-jump[246] = invalidMinor;
-jump[247] = decodeUndefined;
-jump[248] = errorer("simple values are not supported");
-jump[249] = decodeFloat16;
-jump[250] = decodeFloat32;
-jump[251] = decodeFloat64;
-jump[252] = invalidMinor;
-jump[253] = invalidMinor;
-jump[254] = invalidMinor;
-jump[255] = decodeBreak;
-var quick = [];
-for (let i = 0; i < 24; i++) {
-  quick[i] = new Token(Type.uint, i, 1);
-}
-for (let i = -1; i >= -24; i--) {
-  quick[31 - i] = new Token(Type.negint, i, 1);
-}
-quick[64] = new Token(Type.bytes, new Uint8Array(0), 1);
-quick[96] = new Token(Type.string, "", 1);
-quick[128] = new Token(Type.array, 0, 1);
-quick[160] = new Token(Type.map, 0, 1);
-quick[244] = new Token(Type.false, false, 1);
-quick[245] = new Token(Type.true, true, 1);
-quick[246] = new Token(Type.null, null, 1);
-function quickEncodeToken(token) {
-  switch (token.type) {
-    case Type.false:
-      return fromArray([244]);
-    case Type.true:
-      return fromArray([245]);
-    case Type.null:
-      return fromArray([246]);
-    case Type.bytes:
-      if (!token.value.length) {
-        return fromArray([64]);
-      }
-      return;
-    case Type.string:
-      if (token.value === "") {
-        return fromArray([96]);
-      }
-      return;
-    case Type.array:
-      if (token.value === 0) {
-        return fromArray([128]);
-      }
-      return;
-    case Type.map:
-      if (token.value === 0) {
-        return fromArray([160]);
-      }
-      return;
-    case Type.uint:
-      if (token.value < 24) {
-        return fromArray([Number(token.value)]);
-      }
-      return;
-    case Type.negint:
-      if (token.value >= -24) {
-        return fromArray([31 - Number(token.value)]);
-      }
-  }
-}
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/encode.js
-var defaultEncodeOptions = {
-  float64: false,
-  mapSorter,
-  quickEncodeToken
-};
-function makeCborEncoders() {
-  const encoders = [];
-  encoders[Type.uint.major] = encodeUint;
-  encoders[Type.negint.major] = encodeNegint;
-  encoders[Type.bytes.major] = encodeBytes;
-  encoders[Type.string.major] = encodeString;
-  encoders[Type.array.major] = encodeArray;
-  encoders[Type.map.major] = encodeMap;
-  encoders[Type.tag.major] = encodeTag;
-  encoders[Type.float.major] = encodeFloat;
-  return encoders;
-}
-var cborEncoders = makeCborEncoders();
-var buf = new Bl();
-var Ref = class _Ref {
-  /**
-   * @param {object|any[]} obj
-   * @param {Reference|undefined} parent
-   */
-  constructor(obj, parent) {
-    this.obj = obj;
-    this.parent = parent;
-  }
-  /**
-   * @param {object|any[]} obj
-   * @returns {boolean}
-   */
-  includes(obj) {
-    let p = this;
-    do {
-      if (p.obj === obj) {
-        return true;
-      }
-    } while (p = p.parent);
-    return false;
-  }
-  /**
-   * @param {Reference|undefined} stack
-   * @param {object|any[]} obj
-   * @returns {Reference}
-   */
-  static createCheck(stack, obj) {
-    if (stack && stack.includes(obj)) {
-      throw new Error(`${encodeErrPrefix} object contains circular references`);
-    }
-    return new _Ref(obj, stack);
-  }
-};
-var simpleTokens = {
-  null: new Token(Type.null, null),
-  undefined: new Token(Type.undefined, void 0),
-  true: new Token(Type.true, true),
-  false: new Token(Type.false, false),
-  emptyArray: new Token(Type.array, 0),
-  emptyMap: new Token(Type.map, 0)
-};
-var typeEncoders = {
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  number(obj, _typ, _options, _refStack) {
-    if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
-      return new Token(Type.float, obj);
-    } else if (obj >= 0) {
-      return new Token(Type.uint, obj);
-    } else {
-      return new Token(Type.negint, obj);
-    }
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  bigint(obj, _typ, _options, _refStack) {
-    if (obj >= BigInt(0)) {
-      return new Token(Type.uint, obj);
-    } else {
-      return new Token(Type.negint, obj);
-    }
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Uint8Array(obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, obj);
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  string(obj, _typ, _options, _refStack) {
-    return new Token(Type.string, obj);
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  boolean(obj, _typ, _options, _refStack) {
-    return obj ? simpleTokens.true : simpleTokens.false;
-  },
-  /**
-   * @param {any} _obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  null(_obj, _typ, _options, _refStack) {
-    return simpleTokens.null;
-  },
-  /**
-   * @param {any} _obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  undefined(_obj, _typ, _options, _refStack) {
-    return simpleTokens.undefined;
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  ArrayBuffer(obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, new Uint8Array(obj));
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  DataView(obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} options
-   * @param {Reference} [refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Array(obj, _typ, options, refStack) {
-    if (!obj.length) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyArray, new Token(Type.break)];
-      }
-      return simpleTokens.emptyArray;
-    }
-    refStack = Ref.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const e of obj) {
-      entries[i++] = objectToTokens(e, options, refStack);
-    }
-    if (options.addBreakTokens) {
-      return [new Token(Type.array, obj.length), entries, new Token(Type.break)];
-    }
-    return [new Token(Type.array, obj.length), entries];
-  },
-  /**
-   * @param {any} obj
-   * @param {string} typ
-   * @param {EncodeOptions} options
-   * @param {Reference} [refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Object(obj, typ, options, refStack) {
-    const isMap = typ !== "Object";
-    const keys = isMap ? obj.keys() : Object.keys(obj);
-    const length2 = isMap ? obj.size : keys.length;
-    if (!length2) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyMap, new Token(Type.break)];
-      }
-      return simpleTokens.emptyMap;
-    }
-    refStack = Ref.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const key of keys) {
-      entries[i++] = [
-        objectToTokens(key, options, refStack),
-        objectToTokens(isMap ? obj.get(key) : obj[key], options, refStack)
-      ];
-    }
-    sortMapEntries(entries, options);
-    if (options.addBreakTokens) {
-      return [new Token(Type.map, length2), entries, new Token(Type.break)];
-    }
-    return [new Token(Type.map, length2), entries];
-  }
-};
-typeEncoders.Map = typeEncoders.Object;
-typeEncoders.Buffer = typeEncoders.Uint8Array;
-for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
-  typeEncoders[`${typ}Array`] = typeEncoders.DataView;
-}
-function objectToTokens(obj, options = {}, refStack) {
-  const typ = is(obj);
-  const customTypeEncoder = options && options.typeEncoders && /** @type {OptionalTypeEncoder} */
-  options.typeEncoders[typ] || typeEncoders[typ];
-  if (typeof customTypeEncoder === "function") {
-    const tokens = customTypeEncoder(obj, typ, options, refStack);
-    if (tokens != null) {
-      return tokens;
-    }
-  }
-  const typeEncoder = typeEncoders[typ];
-  if (!typeEncoder) {
-    throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
-  }
-  return typeEncoder(obj, typ, options, refStack);
-}
-function sortMapEntries(entries, options) {
-  if (options.mapSorter) {
-    entries.sort(options.mapSorter);
-  }
-}
-function mapSorter(e1, e2) {
-  const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
-  const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
-  if (keyToken1.type !== keyToken2.type) {
-    return keyToken1.type.compare(keyToken2.type);
-  }
-  const major = keyToken1.type.major;
-  const tcmp = cborEncoders[major].compareTokens(keyToken1, keyToken2);
-  if (tcmp === 0) {
-    console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
-  }
-  return tcmp;
-}
-function tokensToEncoded(buf2, tokens, encoders, options) {
-  if (Array.isArray(tokens)) {
-    for (const token of tokens) {
-      tokensToEncoded(buf2, token, encoders, options);
-    }
-  } else {
-    encoders[tokens.type.major](buf2, tokens, options);
-  }
-}
-function encodeCustom(data, encoders, options) {
-  const tokens = objectToTokens(data, options);
-  if (!Array.isArray(tokens) && options.quickEncodeToken) {
-    const quickBytes = options.quickEncodeToken(tokens);
-    if (quickBytes) {
-      return quickBytes;
-    }
-    const encoder = encoders[tokens.type.major];
-    if (encoder.encodedSize) {
-      const size = encoder.encodedSize(tokens, options);
-      const buf2 = new Bl(size);
-      encoder(buf2, tokens, options);
-      if (buf2.chunks.length !== 1) {
-        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-      }
-      return asU8A(buf2.chunks[0]);
-    }
-  }
-  buf.reset();
-  tokensToEncoded(buf, tokens, encoders, options);
-  return buf.toBytes(true);
-}
-function encode4(data, options) {
-  options = Object.assign({}, defaultEncodeOptions, options);
-  return encodeCustom(data, cborEncoders, options);
-}
-
-// ../../node_modules/.pnpm/cborg@4.2.12/node_modules/cborg/lib/decode.js
-var defaultDecodeOptions = {
-  strict: false,
-  allowIndefinite: true,
-  allowUndefined: true,
-  allowBigInt: true
-};
-var Tokeniser = class {
-  /**
-   * @param {Uint8Array} data
-   * @param {DecodeOptions} options
-   */
-  constructor(data, options = {}) {
-    this._pos = 0;
-    this.data = data;
-    this.options = options;
-  }
-  pos() {
-    return this._pos;
-  }
-  done() {
-    return this._pos >= this.data.length;
-  }
-  next() {
-    const byt = this.data[this._pos];
-    let token = quick[byt];
-    if (token === void 0) {
-      const decoder = jump[byt];
-      if (!decoder) {
-        throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
-      }
-      const minor = byt & 31;
-      token = decoder(this.data, this._pos, minor, this.options);
-    }
-    this._pos += token.encodedLength;
-    return token;
-  }
-};
-var DONE = Symbol.for("DONE");
-var BREAK = Symbol.for("BREAK");
-function tokenToArray(token, tokeniser, options) {
-  const arr = [];
-  for (let i = 0; i < token.value; i++) {
-    const value = tokensToObject(tokeniser, options);
-    if (value === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`);
-    }
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`);
-    }
-    arr[i] = value;
-  }
-  return arr;
-}
-function tokenToMap(token, tokeniser, options) {
-  const useMaps = options.useMaps === true;
-  const obj = useMaps ? void 0 : {};
-  const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
-  for (let i = 0; i < token.value; i++) {
-    const key = tokensToObject(tokeniser, options);
-    if (key === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
-    }
-    if (key === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-    }
-    if (useMaps !== true && typeof key !== "string") {
-      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
-    }
-    if (options.rejectDuplicateMapKeys === true) {
-      if (useMaps && m.has(key) || !useMaps && key in obj) {
-        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
-      }
-    }
-    const value = tokensToObject(tokeniser, options);
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
-    }
-    if (useMaps) {
-      m.set(key, value);
-    } else {
-      obj[key] = value;
-    }
-  }
-  return useMaps ? m : obj;
-}
-function tokensToObject(tokeniser, options) {
-  if (tokeniser.done()) {
-    return DONE;
-  }
-  const token = tokeniser.next();
-  if (token.type === Type.break) {
-    return BREAK;
-  }
-  if (token.type.terminal) {
-    return token.value;
-  }
-  if (token.type === Type.array) {
-    return tokenToArray(token, tokeniser, options);
-  }
-  if (token.type === Type.map) {
-    return tokenToMap(token, tokeniser, options);
-  }
-  if (token.type === Type.tag) {
-    if (options.tags && typeof options.tags[token.value] === "function") {
-      const tagged = tokensToObject(tokeniser, options);
-      return options.tags[token.value](tagged);
-    }
-    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
-  }
-  throw new Error("unsupported");
-}
-function decodeFirst(data, options) {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
-  }
-  options = Object.assign({}, defaultDecodeOptions, options);
-  const tokeniser = options.tokenizer || new Tokeniser(data, options);
-  const decoded = tokensToObject(tokeniser, options);
-  if (decoded === DONE) {
-    throw new Error(`${decodeErrPrefix} did not find any content to decode`);
-  }
-  if (decoded === BREAK) {
-    throw new Error(`${decodeErrPrefix} got unexpected break`);
-  }
-  return [decoded, data.subarray(tokeniser.pos())];
-}
-function decode6(data, options) {
-  const [decoded, remainder] = decodeFirst(data, options);
-  if (remainder.length > 0) {
-    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
-  }
-  return decoded;
-}
-
-// ../../node_modules/.pnpm/@ipld+dag-cbor@9.0.5/node_modules/@ipld/dag-cbor/src/index.js
-var CID_CBOR_TAG = 42;
-function cidEncoder(obj) {
-  if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
-    return null;
-  }
-  const cid = CID.asCID(obj);
-  if (!cid) {
-    return null;
-  }
-  const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-  bytes.set(cid.bytes, 1);
-  return [
-    new Token(Type.tag, CID_CBOR_TAG),
-    new Token(Type.bytes, bytes)
-  ];
-}
-function undefinedEncoder() {
-  throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
-}
-function numberEncoder(num) {
-  if (Number.isNaN(num)) {
-    throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  if (num === Infinity || num === -Infinity) {
-    throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  return null;
-}
-var encodeOptions = {
-  float64: true,
-  typeEncoders: {
-    Object: cidEncoder,
-    undefined: undefinedEncoder,
-    number: numberEncoder
-  }
-};
-function cidDecoder(bytes) {
-  if (bytes[0] !== 0) {
-    throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-  }
-  return CID.decode(bytes.subarray(1));
-}
-var decodeOptions = {
-  allowIndefinite: false,
-  coerceUndefinedToNull: true,
-  allowNaN: false,
-  allowInfinity: false,
-  allowBigInt: true,
-  // this will lead to BigInt for ints outside of
-  // safe-integer range, which may surprise users
-  strict: true,
-  useMaps: false,
-  rejectDuplicateMapKeys: true,
-  /** @type {import('cborg').TagDecoder[]} */
-  tags: []
-};
-decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
-var name = "dag-cbor";
-var code = 113;
-var encode5 = (node) => encode4(node, encodeOptions);
-var decode7 = (data) => decode6(data, decodeOptions);
-
-// ../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats/src/hashes/sha2.js
-var import_crypto = __toESM(require("crypto"), 1);
-var sha256 = from2({
-  name: "sha2-256",
-  code: 18,
-  encode: (input) => coerce(import_crypto.default.createHash("sha256").update(input).digest())
-});
-var sha512 = from2({
-  name: "sha2-512",
-  code: 19,
-  encode: (input) => coerce(import_crypto.default.createHash("sha512").update(input).digest())
-});
-
-// dist/esm/src/message-store-sql.js
-var MessageStoreSql = class {
-  #dialect;
-  #tags;
-  #db = null;
-  constructor(dialect) {
-    this.#dialect = dialect;
-    this.#tags = new TagTables(dialect, "messageStoreMessages");
-  }
-  async open() {
-    if (this.#db) {
-      return;
-    }
-    this.#db = new import_kysely7.Kysely({ dialect: this.#dialect });
-    const messagesTableName = "messageStoreMessages";
-    const messagesTableExists = await this.#dialect.hasTable(this.#db, messagesTableName);
-    if (!messagesTableExists) {
-      let createMessagesTable = this.#db.schema.createTable(messagesTableName).ifNotExists().addColumn("tenant", "varchar(255)", (col) => col.notNull()).addColumn("messageCid", "varchar(60)", (col) => col.notNull()).addColumn("interface", "varchar(20)").addColumn("method", "varchar(20)").addColumn("recordId", "varchar(60)").addColumn("entryId", "varchar(60)").addColumn("parentId", "varchar(60)").addColumn("protocol", "varchar(200)").addColumn("protocolPath", "varchar(200)").addColumn("contextId", "varchar(500)").addColumn("schema", "varchar(200)").addColumn("author", "varchar(255)").addColumn("recipient", "varchar(255)").addColumn("messageTimestamp", "varchar(30)").addColumn("dateCreated", "varchar(30)").addColumn("datePublished", "varchar(30)").addColumn("isLatestBaseState", "boolean").addColumn("published", "boolean").addColumn("prune", "boolean").addColumn("dataFormat", "varchar(30)").addColumn("dataCid", "varchar(60)").addColumn("dataSize", "integer").addColumn("encodedData", "text").addColumn("attester", "text").addColumn("permissionGrantId", "varchar(60)").addColumn("latest", "text");
-      createMessagesTable = this.#dialect.addAutoIncrementingColumn(createMessagesTable, "id", (col) => col.primaryKey());
-      createMessagesTable = this.#dialect.addBlobColumn(createMessagesTable, "encodedMessageBytes", (col) => col.notNull());
-      await createMessagesTable.execute();
-      await this.createIndexes(this.#db, messagesTableName, [
-        ["tenant"],
-        ["tenant", "recordId"],
-        ["tenant", "parentId"],
-        ["tenant", "protocol", "published", "messageTimestamp"],
-        ["tenant", "interface"],
-        ["tenant", "contextId", "messageTimestamp"],
-        ["tenant", "permissionGrantId"]
-        // for deleting grant-authorized messages though pending https://github.com/TBD54566975/dwn-sdk-js/issues/716
-        // other potential indexes
-        // ['tenant', 'author'],
-        // ['tenant', 'recipient'],
-        // ['tenant', 'schema', 'dataFormat'],
-        // ['tenant', 'dateCreated'],
-        // ['tenant', 'datePublished'],
-        // ['tenant', 'messageCid'],
-        // ['tenant', 'protocolPath'],
-      ]);
-    }
-    const tagsTableName = "messageStoreRecordsTags";
-    const tagsTableExists = await this.#dialect.hasTable(this.#db, tagsTableName);
-    if (!tagsTableExists) {
-      let createRecordsTagsTable = this.#db.schema.createTable(tagsTableName).ifNotExists().addColumn("tag", "varchar(30)", (col) => col.notNull()).addColumn("valueString", "varchar(200)").addColumn("valueNumber", "decimal");
-      const foreignMessageInsertId = "messageInsertId";
-      createRecordsTagsTable = this.#dialect.addAutoIncrementingColumn(createRecordsTagsTable, "id", (col) => col.primaryKey());
-      createRecordsTagsTable = this.#dialect.addReferencedColumn(createRecordsTagsTable, tagsTableName, foreignMessageInsertId, "integer", "messageStoreMessages", "id", "cascade");
-      await createRecordsTagsTable.execute();
-      await this.createIndexes(this.#db, tagsTableName, [
-        [foreignMessageInsertId],
-        ["tag", "valueString"],
-        ["tag", "valueNumber"]
-      ]);
-    }
-  }
-  /**
-   *  Creates indexes on the given table.
-   * @param tableName The name of the table to create the indexes on.
-   * @param indexes Each inner array represents a single index and contains the column names to be indexed as a composite index.
-   *                If the inner array contains only one element, it will be treated as a single column index.
-   */
-  async createIndexes(database, tableName, indexes) {
-    for (const columnNames of indexes) {
-      const indexName = "index_" + columnNames.join("_");
-      await database.schema.createIndex(indexName).on(tableName).columns(columnNames).execute();
-    }
-  }
-  async close() {
-    await this.#db?.destroy();
-    this.#db = null;
-  }
-  async put(tenant, message, indexes, options) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `put`.");
-    }
-    options?.signal?.throwIfAborted();
-    const getEncodedData = (message2) => {
-      let encodedData2 = null;
-      if (message2.descriptor.interface === import_dwn_sdk_js2.DwnInterfaceName.Records && message2.descriptor.method === import_dwn_sdk_js2.DwnMethodName.Write) {
-        const data = message2.encodedData;
-        if (data) {
-          delete message2.encodedData;
-          encodedData2 = data;
-        }
-      }
-      return { message: message2, encodedData: encodedData2 };
-    };
-    const { message: messageToProcess, encodedData } = getEncodedData(message);
-    const encodedMessageBlock = await (0, import_dwn_sdk_js2.executeUnlessAborted)(encode3({ value: messageToProcess, codec: src_exports, hasher: sha256 }), options?.signal);
-    const messageCid = encodedMessageBlock.cid.toString();
-    const encodedMessageBytes = Buffer.from(encodedMessageBlock.bytes);
-    const putMessageOperation = this.constructPutMessageOperation({ tenant, messageCid, encodedMessageBytes, encodedData, indexes });
-    await executeWithRetryIfDatabaseIsLocked(this.#db, putMessageOperation);
-  }
-  /**
-   * Constructs the transactional operation to insert the given message into the database.
-   */
-  constructPutMessageOperation(queryOptions) {
-    const { tenant, messageCid, encodedMessageBytes, encodedData, indexes } = queryOptions;
-    const { indexes: putIndexes, tags } = extractTagsAndSanitizeIndexes(indexes);
-    return async (tx) => {
-      const messageIndexValues = {
-        tenant,
-        messageCid,
-        encodedMessageBytes,
-        encodedData,
-        ...putIndexes
-      };
-      const result = await this.#dialect.insertThenReturnId(tx, "messageStoreMessages", messageIndexValues, "id as insertId").executeTakeFirstOrThrow();
-      if (Object.keys(tags).length > 0) {
-        await this.#tags.executeTagsInsert(result.insertId, tags, tx);
-      }
-    };
-  }
-  async get(tenant, cid, options) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `get`.");
-    }
-    options?.signal?.throwIfAborted();
-    const result = await (0, import_dwn_sdk_js2.executeUnlessAborted)(this.#db.selectFrom("messageStoreMessages").selectAll().where("tenant", "=", tenant).where("messageCid", "=", cid).executeTakeFirst(), options?.signal);
-    if (!result) {
-      return void 0;
-    }
-    return this.parseEncodedMessage(result.encodedMessageBytes, result.encodedData, options);
-  }
-  async query(tenant, filters, messageSort, pagination, options) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `query`.");
-    }
-    options?.signal?.throwIfAborted();
-    const { property: sortProperty, direction: sortDirection } = this.extractSortProperties(messageSort);
-    let query = this.#db.selectFrom("messageStoreMessages").leftJoin("messageStoreRecordsTags", "messageStoreRecordsTags.messageInsertId", "messageStoreMessages.id").select("messageCid").distinct().select([
-      "encodedMessageBytes",
-      "encodedData",
-      sortProperty
-    ]).where("tenant", "=", tenant);
-    query = filterSelectQuery(filters, query);
-    if (pagination?.cursor !== void 0) {
-      const cursorValue = pagination.cursor.value;
-      const cursorMessageId = pagination.cursor.messageCid;
-      query = query.where(({ eb, refTuple, tuple }) => {
-        const direction = sortDirection === import_dwn_sdk_js2.SortDirection.Ascending ? ">" : "<";
-        return eb(refTuple(sortProperty, "messageCid"), direction, tuple(cursorValue, cursorMessageId));
-      });
-    }
-    const orderDirection = sortDirection === import_dwn_sdk_js2.SortDirection.Ascending ? "asc" : "desc";
-    query = query.orderBy(sortProperty, orderDirection).orderBy("messageCid", orderDirection);
-    if (pagination?.limit !== void 0 && pagination?.limit > 0) {
-      query = query.limit(pagination.limit + 1);
-    }
-    const results = await (0, import_dwn_sdk_js2.executeUnlessAborted)(query.execute(), options?.signal);
-    return this.processPaginationResults(results, sortProperty, pagination?.limit, options);
-  }
-  async delete(tenant, cid, options) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `delete`.");
-    }
-    options?.signal?.throwIfAborted();
-    await (0, import_dwn_sdk_js2.executeUnlessAborted)(this.#db.deleteFrom("messageStoreMessages").where("tenant", "=", tenant).where("messageCid", "=", cid).execute(), options?.signal);
-  }
-  async clear() {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `clear`.");
-    }
-    await this.#db.deleteFrom("messageStoreMessages").execute();
-  }
-  async parseEncodedMessage(encodedMessageBytes, encodedData, options) {
-    options?.signal?.throwIfAborted();
-    const decodedBlock = await decode5({
-      bytes: encodedMessageBytes,
-      codec: src_exports,
-      hasher: sha256
-    });
-    const message = decodedBlock.value;
-    if (message !== void 0 && encodedData !== void 0 && encodedData !== null) {
-      message.encodedData = encodedData;
-    }
-    return message;
-  }
-  /**
-   * Processes the paginated query results.
-   * Builds a pagination cursor if there are additional messages to paginate.
-   * Accepts more messages than the limit, as we query for additional records to check if we should paginate.
-   *
-   * @param messages a list of messages, potentially larger than the provided limit.
-   * @param limit the maximum number of messages to be returned
-   *
-   * @returns the pruned message results and an optional pagination cursor
-   */
-  async processPaginationResults(results, sortProperty, limit, options) {
-    let cursor;
-    if (limit !== void 0 && results.length > limit) {
-      results = results.slice(0, limit);
-      const lastMessage = results.at(-1);
-      const cursorValue = lastMessage[sortProperty];
-      cursor = { messageCid: lastMessage.messageCid, value: cursorValue };
-    }
-    const messages = results.map((r) => this.parseEncodedMessage(r.encodedMessageBytes, r.encodedData, options));
-    return { messages: await Promise.all(messages), cursor };
-  }
-  /**
-   * Extracts the appropriate sort property and direction given a MessageSort object.
-   */
-  extractSortProperties(messageSort) {
-    if (messageSort?.dateCreated !== void 0) {
-      return { property: "dateCreated", direction: messageSort.dateCreated };
-    } else if (messageSort?.datePublished !== void 0) {
-      return { property: "datePublished", direction: messageSort.datePublished };
-    } else if (messageSort?.messageTimestamp !== void 0) {
-      return { property: "messageTimestamp", direction: messageSort.messageTimestamp };
-    } else {
-      return { property: "messageTimestamp", direction: import_dwn_sdk_js2.SortDirection.Ascending };
-    }
-  }
-};
-
-// dist/esm/src/resumable-task-store-sql.js
-var import_kysely8 = require("kysely");
-var import_dwn_sdk_js3 = require("@enbox/dwn-sdk-js");
-var ResumableTaskStoreSql = class _ResumableTaskStoreSql {
-  static taskTimeoutInSeconds = 60;
-  #dialect;
-  #db = null;
-  constructor(dialect) {
-    this.#dialect = dialect;
-  }
-  async open() {
-    if (this.#db) {
-      return;
-    }
-    this.#db = new import_kysely8.Kysely({ dialect: this.#dialect });
-    const tableName = "resumableTasks";
-    const tableExists = await this.#dialect.hasTable(this.#db, tableName);
-    if (tableExists) {
-      return;
-    }
-    let table = this.#db.schema.createTable(tableName).ifNotExists().addColumn("id", "varchar(255)", (col) => col.primaryKey()).addColumn("task", "text").addColumn("timeout", "bigint").addColumn("retryCount", "integer");
-    await table.execute();
-    await this.#db.schema.createIndex("index_timeout").on("resumableTasks").column("timeout").execute();
-  }
-  async close() {
-    await this.#db?.destroy();
-    this.#db = null;
-  }
-  async register(task, timeoutInSeconds) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `register`.");
-    }
-    const id = await import_dwn_sdk_js3.Cid.computeCid(task);
-    const timeout = Date.now() + timeoutInSeconds * 1e3;
-    const taskString = JSON.stringify(task);
-    const retryCount = 0;
-    const taskEntryInDatabase = { id, task: taskString, timeout, retryCount };
-    await this.#db.insertInto("resumableTasks").values(taskEntryInDatabase).execute();
-    return {
-      id,
-      task,
-      retryCount,
-      timeout
-    };
-  }
-  async grab(count) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `grab`.");
-    }
-    const now = Date.now();
-    const newTimeout = now + _ResumableTaskStoreSql.taskTimeoutInSeconds * 1e3;
-    let tasks = [];
-    const operation = async (transaction) => {
-      tasks = await transaction.selectFrom("resumableTasks").selectAll().where("timeout", "<=", now).limit(count).execute();
-      if (tasks.length > 0) {
-        const ids = tasks.map((task) => task.id);
-        await transaction.updateTable("resumableTasks").set({ timeout: newTimeout }).where((eb) => eb("id", "in", ids)).execute();
-      }
-    };
-    await executeWithRetryIfDatabaseIsLocked(this.#db, operation);
-    const tasksToReturn = tasks.map((task) => {
-      return {
-        id: task.id,
-        task: JSON.parse(task.task),
-        retryCount: task.retryCount,
-        timeout: task.timeout
-      };
-    });
-    return tasksToReturn;
-  }
-  async read(taskId) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `read`.");
-    }
-    const task = await this.#db.selectFrom("resumableTasks").selectAll().where("id", "=", taskId).executeTakeFirst();
-    if (task !== void 0) {
-      if (typeof task.timeout !== "number") {
-        task.timeout = parseInt(task.timeout, 10);
-      }
-    }
-    return task;
-  }
-  async extend(taskId, timeoutInSeconds) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `extend`.");
-    }
-    const timeout = Date.now() + timeoutInSeconds * 1e3;
-    await this.#db.updateTable("resumableTasks").set({ timeout }).where("id", "=", taskId).execute();
-  }
-  async delete(taskId) {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `delete`.");
-    }
-    await this.#db.deleteFrom("resumableTasks").where("id", "=", taskId).execute();
-  }
-  async clear() {
-    if (!this.#db) {
-      throw new Error("Connection to database not open. Call `open` before using `clear`.");
-    }
-    await this.#db.deleteFrom("resumableTasks").execute();
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DataStoreSql,
-  EventLogSql,
-  MessageStoreSql,
-  MysqlDialect,
-  PostgresDialect,
-  ResumableTaskStoreSql,
-  SqliteDialect
-});