okmodel 0.5.1 → 0.7.0

package/dist/shared/{5enne4ma.js → xnxsed62.js}

@@ -1,24 +1,32 @@
+import {
+  UUIDV7_POSTGRES,
+  isPostgresMajor,
+  parsePostgresFloor,
+  formatPostgresFloor,
+  minPostgresDefinition,
+  uuidv7NeedsPostgres
+} from "./ga9j92qj.js";
 import {
   catalog,
   enumType,
   sameEnumLabels
-} from "./g7ez901n.js";
-import {
-  snakeCase,
-  emittedTypeName,
-  rejectLater
-} from "./ntneex2a.js";
+} from "./ywspezzx.js";
 import {
-  withLocation
-} from "./k7dwkhvq.js";
+  isRelationCall
+} from "./exn3sd90.js";
 import {
   encodeText,
   decodeText
-} from "./4m9fn52z.js";
+} from "./ed0b8k4s.js";
+import {
+  snakeCase,
+  emittedTypeName,
+  rejectLater
+} from "./rpycarcr.js";
 import {
   ColumnBuilder2,
   formatType
-} from "./c9z5g0fm.js";
+} from "./ywr8hmey.js";
 import {
   definition,
   unavailable
@@ -26,6 +34,9 @@ import {
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
+import {
+  withLocation
+} from "./y6jdds7g.js";
 import {
   staticNamespace2,
   table3,
@@ -34,7 +45,7 @@ import {
   constraint2,
   sequence2,
   compareText
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   assertIdentifier2,
   fitIdentifier2,
@@ -49,85 +60,6 @@ import {
   readClientGenerator
 } from "./rwmrejjz.js";
 
-// src/dialects/pg/through.ts
-var emit = (planner, schema, relation, child, sink, parent, alias, depth) => {
-  const through = relation.through;
-  const join = through === undefined ? undefined : planner.indexes(schema).get(through.table);
-  if (through === undefined || join === undefined) {
-    return catalogError2("OKM1020", `Relation ${relation.name} names a join table that is not in the schema.`);
-  }
-  const { quote } = planner;
-  const joinAlias = `j${alias}`;
-  sink.mark(`via:${through.table}`);
-  sink.text(`${quote(join.model.sql)} ${joinAlias} join ${quote(child.model.sql)} ${alias} on `);
-  for (let index = 0;index < through.local.length; index += 1) {
-    const local = through.local[index];
-    const remote = through.remote[index];
-    if (local === undefined || remote === undefined)
-      continue;
-    if (index > 0)
-      sink.text(" and ");
-    sink.text(`${alias}.${quote(remote)} = ${joinAlias}.${quote(local)}`);
-  }
-  sink.text(" where ");
-  planner.join(sink, parent, joinAlias, relation);
-  planner.where(schema, join, undefined, sink, joinAlias, depth + 1, true);
-};
-function resolveThrough(scope, table, through, from, to) {
-  for (const name of [table, through]) {
-    if (!scope.tables.includes(name)) {
-      throwNamed2("OKM1020", name, scope.tables, `Relation ${scope.owner}.${scope.name} names ${name}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
-    }
-  }
-  const toOwner = pick(scope, through, scope.owner, from, `${scope.owner}.${scope.name}`, "from");
-  const toTable = pick(scope, through, table, to, `${scope.owner}.${scope.name}`, "to");
-  if (toOwner === toTable) {
-    catalogError2("OKM1021", `Relation ${scope.owner}.${scope.name} uses ${toOwner.fromField} on ${through} for both ends. Pass from and to.`);
-  }
-  return {
-    name: scope.name,
-    kind: "many",
-    table,
-    local: toOwner.remote,
-    remote: toOwner.local,
-    through: { table: through, local: toTable.local, remote: toTable.remote, emit }
-  };
-}
-function pick(scope, through, target, field, label, end) {
-  const matches = scope.edges.filter((edge) => edge.fromTable === through && edge.toTable === target && (field === undefined || edge.fromField === field));
-  const [only] = matches;
-  if (matches.length === 1 && only !== undefined)
-    return only;
-  const fields = matches.map((edge) => edge.fromField).sort();
-  catalogError2("OKM1021", `Relation ${label} through ${through} is ambiguous at ${end}. Accepted columns: ${fields.length === 0 ? "(none)" : fields.join(", ")}.`);
-}
-
-// src/dialects/pg/relations.ts
-function one2(table, field) {
-  return { kind: "one", table, field };
-}
-function many2(table, field) {
-  return { kind: "many", table, field };
-}
-function isRelationCall(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  if (!("kind" in value) || !("table" in value))
-    return false;
-  const kind = value.kind;
-  return (kind === "one" || kind === "many") && typeof value.table === "string";
-}
-function manyThrough2(table, options) {
-  const { through, from, to } = options;
-  return {
-    kind: "many",
-    table,
-    field: undefined,
-    through,
-    resolve: (scope) => resolveThrough(scope, table, through, from, to)
-  };
-}
-
 // src/dialects/pg/compile.ts
 function compileColumn(builder, input) {
   const state = builder.state;
@@ -212,7 +144,7 @@ function readTenancy(value) {
     definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
   }
   const record = value;
-  if (record.strategy !== "column" || typeof record.rewrite !== "function") {
+  if (typeof record.rewrite !== "function") {
     definition("schema() tenancy must be columnTenancy() from okmodel/tenancy.");
   }
   return value;
@@ -225,6 +157,7 @@ var SCHEMA_KNOWN = new Set([
   "defaults",
   "extensions",
   "functions",
+  "minPostgres",
   "requires",
   "tables",
   "tenancy",
@@ -254,7 +187,7 @@ function schema2(config) {
   const hooks = collectHooks(tenancy, schemaTraits, config.tables, config.views);
   const types = readTypes(config.types);
   const codecs = readCodecs(config.codecs);
-  const requires = readRequires(config.requires);
+  const requires = readFloor(config.minPostgres, config.requires);
   const idDefault = readIdDefault(config.defaults);
   const namespace = staticNamespace2("public");
   const accepted = acceptTables(config.tables);
@@ -279,8 +212,9 @@ function schema2(config) {
     compileForeignKeys(item, byName, accepted, jobs, edges);
   }
   const model = {};
+  const scopeFields = tenancy === undefined ? undefined : tenancy.keys !== undefined ? tenancy.keys : [tenancy.key];
   for (const item of prepared) {
-    model[item.tsName] = tableModel(item, edges, byName, accepted);
+    model[item.tsName] = tableModel(item, edges, byName, accepted, scopeFields);
   }
   bindViews(config.views, model, tenancy, tables, casing);
   let document;
@@ -557,7 +491,7 @@ function compileTable(item, namespace, casing, codecs, requires, idDefault, jobs
       references: column.state.references,
       encode: column.state.encode,
       decode: decode === decodeText ? undefined : decode,
-      hidden: column.state.hidden,
+      hidden: column.state.filterable === true ? "filter" : column.state.hidden,
       sensitive: column.state.sensitive,
       guarded: column.state.guarded,
       writable: column.state.guarded !== true && column.state.omitWrite !== true && column.state.generated === undefined,
@@ -578,7 +512,7 @@ function compileTable(item, namespace, casing, codecs, requires, idDefault, jobs
       columnPrimary.push(prepared.sqlName);
     }
     if (column.state.defaultSql === "uuidv7()") {
-      refuseUuidV7(item.name, field, requires);
+      refuseUuidV7(requires);
     }
     const labels = column.state.enumLabels;
     if (labels !== undefined) {
@@ -934,7 +868,7 @@ function readCodecs(codecs) {
   }
   return { bigint, numeric, timestamps };
 }
-function tableModel(item, edges, byName, accepted) {
+function tableModel(item, edges, byName, accepted, scopeFields) {
   const primary = [];
   for (const sqlName of item.primary) {
     const column = item.bySql.get(sqlName);
@@ -967,7 +901,7 @@ function tableModel(item, edges, byName, accepted) {
     primary,
     uniques: item.uniques,
     columns,
-    relations: resolveRelations(item, edges, byName, accepted),
+    relations: resolveRelations(item, edges, byName, accepted, scopeFields),
     ...conceal ? { conceal: true } : {},
     ...item.traits !== undefined ? { traits: item.traits } : {},
     ...item.provenance.source !== undefined ? { source: item.provenance.source } : {},
@@ -975,10 +909,11 @@ function tableModel(item, edges, byName, accepted) {
     ...item.presets !== undefined ? { presets: item.presets } : {}
   };
 }
-function resolveRelations(item, edges, byName, accepted) {
+function resolveRelations(item, edges, byName, accepted, scopeFields) {
   const raw = item.relationOptions;
   if (raw === undefined)
     return [];
+  const describe = (table) => byName.get(table);
   const record = raw;
   const names = Object.keys(record);
   const resolved = [];
@@ -989,11 +924,18 @@ function resolveRelations(item, edges, byName, accepted) {
     seen.add(name);
     const call = record[name];
     if (!isRelationCall(call)) {
-      unavailable(`Table ${item.tsName} relation ${name} is not available yet. one(), many(), and manyThrough() are accepted. morph arrives later.`);
+      unavailable(`Table ${item.tsName} relation ${name} is not a relation. one(), many(), manyThrough(), morph(), and morphMany() are accepted.`);
     }
     const own = call.resolve;
     if (own !== undefined) {
-      resolved.push(own({ owner: item.tsName, name, edges, tables: accepted }));
+      resolved.push(own({
+        owner: item.tsName,
+        name,
+        edges,
+        tables: accepted,
+        describe,
+        ...scopeFields === undefined ? {} : { scopeFields }
+      }));
       continue;
     }
     if (!byName.has(call.table)) {
@@ -1078,21 +1020,32 @@ function readIdDefault(defaults) {
     return { kind: "client", fill };
   definition('schema() defaults.id must be "uuidv7", "uuidv4", or a client generator.');
 }
-function refuseUuidV7(tableName, field, requires) {
-  const declared = Number(/^>=(\d+)$/.exec(requires?.postgres ?? "")?.[1]);
-  if (!(declared > 0) || declared >= 18)
+function refuseUuidV7(requires) {
+  const declared = parsePostgresFloor(requires?.postgres);
+  if (!(declared > 0) || declared >= UUIDV7_POSTGRES)
     return;
-  throw new OkmError2("OKM1812", `Column ${tableName}.${field} uses uuidv7(). Set defaults.id to "uuidv4" or a client generator.`, { fix: { summary: "Set defaults.id." } });
+  const sentence = uuidv7NeedsPostgres();
+  throw new OkmError2("OKM1812", sentence, { fix: { summary: sentence } });
 }
-function readRequires(requires) {
-  if (requires === undefined) {
-    return;
-  }
-  const postgres = requires.postgres;
-  if (postgres !== undefined && postgres.length === 0) {
-    definition("schema() requires.postgres must be a version range such as >=17.");
+function readFloor(minPostgres, requires) {
+  if (minPostgres !== undefined && requires !== undefined) {
+    definition("minPostgres or requires.postgres, not both.");
   }
-  return postgres === undefined ? {} : { postgres };
+  if (minPostgres === undefined && requires === undefined)
+    return;
+  let major = minPostgres;
+  if (minPostgres === undefined) {
+    if (typeof requires !== "object" || requires === null || Array.isArray(requires)) {
+      definition(minPostgresDefinition());
+    }
+    const postgres = requires.postgres;
+    if (postgres === undefined)
+      return {};
+    major = typeof postgres === "string" ? parsePostgresFloor(postgres) : NaN;
+  }
+  if (!isPostgresMajor(major))
+    definition(minPostgresDefinition());
+  return { postgres: formatPostgresFloor(major) };
 }
 function readIndex(tableName, call) {
   if (call.columns.length === 0) {
@@ -1127,4 +1080,4 @@ function list(names) {
   return names.length === 0 ? "(none)" : names.join(", ");
 }
 
-export { one2, many2, manyThrough2, schema2, addSchemaHook };
+export { schema2, addSchemaHook };

package/dist/shared/xqve9598.js

@@ -0,0 +1,53 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/owner.ts
+var MARKS = new WeakMap;
+function withOwner2(table, owner) {
+  if (owner !== "external" && owner !== "ignored") {
+    throw new OkmError2("invalid", `Table owner ${String(owner)} is not external or ignored.`, {
+      kind: "invalid",
+      fix: { summary: "Pass external or ignored. Omit the mark for a managed table." }
+    });
+  }
+  MARKS.set(table, owner);
+  return table;
+}
+function tableOwner(table) {
+  return MARKS.get(table);
+}
+function stampOwnership(source, marks) {
+  if (marks.size === 0)
+    return source;
+  let changed = false;
+  const objects = source.objects.map((object) => {
+    const owner = ownerFor(object, marks);
+    if (owner === undefined || object.owner === owner)
+      return object;
+    changed = true;
+    return { ...object, owner };
+  });
+  if (!changed)
+    return source;
+  return { version: source.version, objects };
+}
+function ownerFor(object, marks) {
+  if (object.kind === "table")
+    return marks.get(object.identity.name);
+  if (object.kind === "column" || object.kind === "index" || object.kind === "constraint" || object.kind === "trigger" || object.kind === "policy") {
+    return marks.get(object.identity.parent.name);
+  }
+  if (object.kind === "sequence") {
+    for (const edge of object.dependencies) {
+      if (edge.target.kind !== "table")
+        continue;
+      const owner = marks.get(edge.target.name);
+      if (owner !== undefined)
+        return owner;
+    }
+  }
+  return;
+}
+
+export { withOwner2, tableOwner, stampOwnership };

package/dist/shared/{9x25fxhc.js → y34a8714.js}

@@ -3,7 +3,7 @@ import {
   assertNamespace2,
   normaliseEdges,
   assertProvenance
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   assertIdentifier2
 } from "./nfzc5z0w.js";

package/dist/shared/{k7dwkhvq.js → y6jdds7g.js}

@@ -4,9 +4,12 @@ function callerLocation(skip) {
 `);
   if (lines === undefined)
     return;
+  return locationFromLines(lines, skip);
+}
+function locationFromLines(lines, skip) {
   let left = skip;
   for (const line of lines) {
-    const slash = line.lastIndexOf("/");
+    const slash = Math.max(line.lastIndexOf("/"), line.lastIndexOf("\\"));
     if (slash < 0)
       continue;
     const tail = line.slice(slash + 1);

package/dist/shared/y6njgyda.js

@@ -0,0 +1,249 @@
+import {
+  stack2
+} from "./mss6ctgv.js";
+import {
+  updateSliceBody2,
+  rejectDuplicateTargets2,
+  emitSet2,
+  Sql2,
+  writeSet2,
+  rejectMixedSets2,
+  readClaim2,
+  rejectUpdateKeys2,
+  requireFilter2,
+  returningOption2,
+  expectOf2,
+  allowSet2,
+  noteGuarded2
+} from "./1w508jbr.js";
+import {
+  emitWhere,
+  projectExpr,
+  quote,
+  isRecord,
+  fail2
+} from "./67txcrcw.js";
+
+// src/runtime/version.ts
+function planVersioned(schema, table, input, options, mods) {
+  if (mods.all !== undefined) {
+    fail2("OKM1120", `update on ${table.model.name} cannot use .all() with versioned().`, "Pass a per-row list with the version you read for each row.");
+  }
+  const allow = allowSet2(table, options.allow);
+  noteGuarded2(table, allow, "update");
+  const column = versionColumn(table);
+  const returning = returningOption2(table, options.returning);
+  const expect = expectOf2(options, mods);
+  if (Array.isArray(input) && input.length === 0) {
+    return {
+      statements: [],
+      outputs: outputsOf(undefined),
+      shape: "count",
+      expect,
+      versioned: { fields: [], sent: [] }
+    };
+  }
+  const rows = readRows(schema, table, input, allow, mods, column);
+  const fields = writtenFields(rows);
+  const sent = rows.map((row) => row.version);
+  const claim = Array.isArray(input) ? undefined : isRecord(input) ? readClaim2(input) : undefined;
+  const statement = claim !== undefined ? claimStatement(schema, table, rows[0], claim, column, returning) : targetStatement(schema, table, rows, column, returning);
+  const width = statement.params?.length ?? 0;
+  if (width > 30000) {
+    fail2("OKM1120", `update on ${table.model.name} is too large to check version in one statement.`, "Split the list.");
+  }
+  return {
+    statements: [statement],
+    outputs: outputsOf(returning),
+    shape: returning === undefined ? "count" : "rows",
+    expect,
+    versioned: { fields, sent }
+  };
+}
+function versionColumn(table) {
+  const column = table.columns.get("version");
+  if (column === undefined) {
+    fail2("OKM1120", `Table ${table.model.name} is versioned and has no version column.`);
+  }
+  return column;
+}
+function readRows(schema, table, input, allow, mods, column) {
+  if (Array.isArray(input)) {
+    if (input.length === 0)
+      fail2("OKM1120", "update set is empty.");
+    const rows = input.map((item) => readRow(schema, table, item, allow, mods, column, true));
+    rejectDuplicateTargets2(table, rows);
+    rejectMixedSets2(rows);
+    return rows;
+  }
+  return [readRow(schema, table, input, allow, mods, column, false)];
+}
+function readRow(schema, table, input, allow, mods, column, row) {
+  if (!isRecord(input))
+    fail2("OKM1121", "update expects { where, set, version } or a list of rows.");
+  rejectUpdateKeys2(input, row);
+  if (!Object.hasOwn(input, "version")) {
+    fail2("OKM1120", `update on ${table.model.name} needs the version you read.`, "Pass version from the row you read. If this write conflicts, reread and retry.");
+  }
+  const version = readVersion(input.version, table.model.name, column);
+  const set = writeSet2(table, input.set, allow, schema.tenancy);
+  if (Object.keys(set).length === 0)
+    fail2("OKM1120", "update set is empty.");
+  refusePath(schema, table, set);
+  const where = input.where !== undefined ? input.where : input.id !== undefined ? { id: input.id } : undefined;
+  requireFilter2(table, where, mods, "update");
+  return { where: stack2(where, mods.presets), set, version };
+}
+function readVersion(value, table, column) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    fail2("OKM1121", `version on ${table} must be an integer.`, "Pass the version you read.");
+  }
+  column.encode(value);
+  return value;
+}
+function refusePath(schema, table, set) {
+  if (schema.tenancy?.isPath?.(table.model.name) !== true)
+    return;
+  const field = schema.tenancy.pathOf?.(table.model.name)?.[0]?.localField;
+  if (field === undefined || !Object.hasOwn(set, field))
+    return;
+  fail2("OKM1120", `update on ${table.model.name} cannot change ${field} and check version in one write.`, "Point it at a parent in a later update.");
+}
+function writtenFields(rows) {
+  const names = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row.set))
+      if (!names.includes(key))
+        names.push(key);
+  }
+  return names;
+}
+function targetStatement(schema, table, rows, column, returning) {
+  const sql = new Sql2;
+  sql.text("with ");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(", ");
+    sql.text("m");
+    sql.text(String(index));
+    sql.text(" as (select s.ctid as tid, s.tableoid as toid, s.");
+    sql.text(quote(column.sql));
+    sql.text(" as okm_version from ");
+    sql.text(quote(table.model.sql));
+    sql.text(" as s");
+    emitWhere(schema, table, row.where, sql.sink(), "s", 0);
+    sql.text(" for update of s)");
+  }
+  sql.text(", gate as (select count(*)::int as n from (");
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === undefined)
+      continue;
+    if (index > 0)
+      sql.text(" union all ");
+    sql.text("select 1 from m");
+    sql.text(String(index));
+    sql.text(" where okm_version is distinct from ");
+    sql.param(column.encode(row.version), column.dataType);
+  }
+  sql.text(") as okm_diff), updated as (");
+  updateSliceBody2(schema, table, rows, sql, true, {
+    afterWhere(body, index) {
+      const row = rows[index];
+      if (row === undefined)
+        return;
+      body.text(" and t.");
+      body.text(quote(column.sql));
+      body.text(" = ");
+      body.param(column.encode(row.version), column.dataType);
+    },
+    afterSet(body) {
+      bump(body, column);
+    }
+  });
+  sql.text(" and (select n from gate) = 0");
+  closeUpdated(sql, returning, "gate");
+  return sql.statement();
+}
+function claimStatement(schema, table, row, limit, column, returning) {
+  if (row === undefined)
+    fail2("OKM1120", "update set is empty.");
+  const sql = new Sql2;
+  sql.text("with claimed as (select s.tableoid as toid, s.ctid as tid from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as s");
+  emitWhere(schema, table, row.where, sql.sink(), "s", 0);
+  sql.text(" and s.");
+  sql.text(quote(column.sql));
+  sql.text(" = ");
+  sql.param(column.encode(row.version), column.dataType);
+  sql.text(" for update of s skip locked limit ");
+  sql.param(String(limit), "integer");
+  sql.text("), stale_free as (select 1 as hit from ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as s");
+  emitWhere(schema, table, row.where, sql.sink(), "s", 0);
+  sql.text(" and s.");
+  sql.text(quote(column.sql));
+  sql.text(" is distinct from ");
+  sql.param(column.encode(row.version), column.dataType);
+  sql.text(" for update of s skip locked limit 1), updated as (update ");
+  sql.text(quote(table.model.sql));
+  sql.text(" as t set ");
+  emitSet2(sql, table, row.set, "t");
+  bump(sql, column);
+  sql.text(" where (t.tableoid, t.ctid) in (select toid, tid from claimed)");
+  closeUpdated(sql, returning, "claim");
+  return sql.statement();
+}
+function bump(sql, column) {
+  sql.text(", ");
+  sql.text(quote(column.sql));
+  sql.text(" = t.");
+  sql.text(quote(column.sql));
+  sql.text(" + 1");
+}
+function closeUpdated(sql, returning, source) {
+  const stale = source === "gate" ? "(select n from gate)" : "(case when (select count(*) from updated) > 0 then 0 else (select count(*)::int from stale_free) end)";
+  if (returning === undefined || returning.length === 0) {
+    sql.text(" returning 1) select ");
+    sql.text(stale);
+    sql.text(", (select count(*)::int from updated)");
+    return;
+  }
+  sql.text(" returning t.ctid as okm_tid");
+  for (let index = 0;index < returning.length; index += 1) {
+    const column = returning[index];
+    if (column === undefined)
+      continue;
+    sql.text(", ");
+    sql.text(projectExpr(`t.${quote(column.sql)}`, column.dataType));
+    sql.text(" as okm_");
+    sql.text(String(index));
+  }
+  sql.text(") select ");
+  sql.text(stale);
+  sql.text(", case when u.okm_tid is null then 0 else 1 end");
+  for (let index = 0;index < returning.length; index += 1) {
+    sql.text(", u.okm_");
+    sql.text(String(index));
+  }
+  sql.text(" from (select 1) as okm_one left join updated u on true");
+}
+function outputsOf(columns) {
+  const list = columns ?? [];
+  return {
+    fields: list.map((column, index) => ({
+      key: column.field,
+      at: index + 2,
+      decode: column.decode
+    })),
+    includes: []
+  };
+}
+export {
+  planVersioned
+};

package/dist/shared/{c9z5g0fm.js → ywr8hmey.js}

@@ -135,8 +135,11 @@ class ColumnBuilder2 {
   guarded() {
     return rebuild(this.state, { guarded: true });
   }
-  hidden() {
-    return rebuild(this.state, { hidden: true });
+  hidden(options) {
+    return rebuild(this.state, {
+      hidden: true,
+      ...options?.filterable === true ? { filterable: true } : {}
+    });
   }
   sensitive() {
     return rebuild(this.state, { sensitive: true });

package/dist/shared/{g7ez901n.js → ywspezzx.js}

@@ -5,7 +5,7 @@ import {
   normaliseEdges,
   compareText,
   assertProvenance
-} from "./t4tbsy9h.js";
+} from "./358zsv4r.js";
 import {
   CATALOG_VERSION2
 } from "./4e4c6vq2.js";