tla-ts 0.0.4-dev.a297123 → 0.0.4-dev.e92649a

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (311) hide show
  1. package/README.md +26 -141
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +515 -0
  15. package/dist/prove.js +515 -0
  16. package/dist/run-cli.cjs +30 -47
  17. package/dist/run-cli.js +30 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +5 -3
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +54 -19
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  35. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  36. package/src/{obligations.ts → obligations/index.ts} +26 -12
  37. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  38. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  39. package/src/obligations/pickle.ts +100 -0
  40. package/src/obligations/pragma.ts +189 -0
  41. package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
  42. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  43. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  44. package/src/obligations/temporal.ts +319 -0
  45. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +27 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +477 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +27 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +29 -0
  115. package/src/prove/prove.ts +417 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +96 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +13 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +73 -20
  303. package/src/standard-modules.ts +5 -2
  304. package/src/successors.ts +24 -5
  305. package/src/tlc-random.ts +55 -32
  306. package/src/tlc-version.ts +8 -7
  307. package/src/values.ts +80 -35
  308. package/src/worker.ts +65 -0
  309. package/dist/parallel.cjs +0 -12
  310. package/dist/parallel.js +0 -12
  311. /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
@@ -0,0 +1,276 @@
1
+ // Decides satisfiability of propositional linear temporal logic over infinite traces, the logic LS4
2
+ // decides. A tableau node is the set of formulas that must hold now. A SAT call per step picks the
3
+ // atoms and the formulas the next node must hold, and the formula is satisfiable when a reachable
4
+ // strongly connected component can fulfill every eventuality it postpones.
5
+
6
+ import type { Verdict } from "../verdict";
7
+ import { createSolver } from "./sat";
8
+
9
+ export type PtlFormula =
10
+ | { kind: "Atom"; name: string }
11
+ | { kind: "Not" | "Next" | "Always" | "Eventually"; body: PtlFormula }
12
+ | { kind: "And" | "Or" | "Implies" | "Equiv"; left: PtlFormula; right: PtlFormula };
13
+
14
+ // Formulas in negation normal form, numbered so that equal formulas share a number.
15
+ type Normal =
16
+ | { kind: "Constant"; value: boolean }
17
+ | { kind: "Literal"; atom: string; isPositive: boolean }
18
+ | { kind: "And" | "Or"; children: number[] }
19
+ | { kind: "Next" | "Always" | "Eventually"; body: number };
20
+
21
+ interface Step {
22
+ next: number[];
23
+ pending: number[];
24
+ }
25
+
26
+ interface Edge {
27
+ target: number;
28
+ pending: number[];
29
+ }
30
+
31
+ const createTable = () => {
32
+ const normals: Normal[] = [];
33
+ const numbers = new Map<string, number>();
34
+ const intern = (key: string, normal: Normal) => {
35
+ const existing = numbers.get(key);
36
+ if (existing !== undefined) return existing;
37
+ numbers.set(key, normals.length);
38
+ normals.push(normal);
39
+ return normals.length - 1;
40
+ };
41
+ const getConstant = (value: boolean) => intern(String(value), { kind: "Constant", value });
42
+ const getJunction = (kind: "And" | "Or", operands: number[]): number => {
43
+ const absorbing = kind === "Or";
44
+ const children = new Set<number>();
45
+ for (const operand of operands) {
46
+ const normal = normals[operand];
47
+ if (normal.kind === "Constant") {
48
+ if (normal.value === absorbing) return operand;
49
+ continue;
50
+ }
51
+ if (normal.kind === kind) normal.children.forEach((child) => children.add(child));
52
+ else children.add(operand);
53
+ }
54
+ const sorted = [...children].sort((left, right) => left - right);
55
+ if (sorted.length === 0) return getConstant(!absorbing);
56
+ if (sorted.length === 1) return sorted[0];
57
+ return intern(`${kind}(${sorted.join(",")})`, { kind, children: sorted });
58
+ };
59
+ const getModal = (kind: "Next" | "Always" | "Eventually", body: number) => {
60
+ const normal = normals[body];
61
+ if (normal.kind === "Constant" || (kind !== "Next" && normal.kind === kind)) return body;
62
+ return intern(`${kind}(${body})`, { kind, body });
63
+ };
64
+ const memo = [new WeakMap<PtlFormula, number>(), new WeakMap<PtlFormula, number>()];
65
+ const normalize = (formula: PtlFormula, isNegated: boolean): number => {
66
+ const cache = memo[isNegated ? 1 : 0];
67
+ const cached = cache.get(formula);
68
+ if (cached !== undefined) return cached;
69
+ const result = ((): number => {
70
+ switch (formula.kind) {
71
+ case "Atom":
72
+ return intern(`${isNegated ? "-" : "+"}${formula.name}`, {
73
+ kind: "Literal",
74
+ atom: formula.name,
75
+ isPositive: !isNegated,
76
+ });
77
+ case "Not":
78
+ return normalize(formula.body, !isNegated);
79
+ case "Next":
80
+ return getModal("Next", normalize(formula.body, isNegated));
81
+ case "Always":
82
+ case "Eventually":
83
+ return getModal(
84
+ (formula.kind === "Always") === isNegated ? "Eventually" : "Always",
85
+ normalize(formula.body, isNegated),
86
+ );
87
+ case "And":
88
+ case "Or":
89
+ return getJunction((formula.kind === "And") === isNegated ? "Or" : "And", [
90
+ normalize(formula.left, isNegated),
91
+ normalize(formula.right, isNegated),
92
+ ]);
93
+ case "Implies":
94
+ return getJunction(isNegated ? "And" : "Or", [
95
+ normalize(formula.left, !isNegated),
96
+ normalize(formula.right, isNegated),
97
+ ]);
98
+ case "Equiv":
99
+ return getJunction(isNegated ? "Or" : "And", [
100
+ getJunction(isNegated ? "And" : "Or", [
101
+ normalize(formula.left, !isNegated),
102
+ normalize(formula.right, isNegated),
103
+ ]),
104
+ getJunction(isNegated ? "And" : "Or", [
105
+ normalize(formula.left, isNegated),
106
+ normalize(formula.right, !isNegated),
107
+ ]),
108
+ ]);
109
+ }
110
+ })();
111
+ cache.set(formula, result);
112
+ return result;
113
+ };
114
+ return { normals, normalize };
115
+ };
116
+
117
+ // Every way to satisfy the formulas now, keeping only the steps that require the fewest next
118
+ // formulas and leave the fewest eventualities pending. A step that requires more of both can only
119
+ // do what a smaller one can, so dropping it keeps the decision complete. Undefined once isExpired
120
+ // turns true.
121
+ const getSteps = (
122
+ normals: Normal[],
123
+ formulas: number[],
124
+ isExpired: () => boolean,
125
+ ): Step[] | undefined => {
126
+ const clauses: number[][] = [];
127
+ const atoms = new Map<string, number>();
128
+ const nexts = new Map<number, number>();
129
+ const pendings = new Map<number, number>();
130
+ const literals = new Map<number, number>();
131
+ const counter = { value: 0 };
132
+ const createVariable = () => ++counter.value;
133
+ const getVariable = <Key>(variables: Map<Key, number>, key: Key) => {
134
+ const existing = variables.get(key);
135
+ if (existing !== undefined) return existing;
136
+ const variable = createVariable();
137
+ variables.set(key, variable);
138
+ return variable;
139
+ };
140
+ // Plaisted-Greenbaum: a formula's literal implies the formula, which suffices in normal form.
141
+ const encode = (formula: number): number => {
142
+ const cached = literals.get(formula);
143
+ if (cached !== undefined) return cached;
144
+ const normal = normals[formula];
145
+ const literal = ((): number => {
146
+ switch (normal.kind) {
147
+ case "Constant": {
148
+ const variable = createVariable();
149
+ clauses.push([normal.value ? variable : -variable]);
150
+ return variable;
151
+ }
152
+ case "Literal": {
153
+ const variable = getVariable(atoms, normal.atom);
154
+ return normal.isPositive ? variable : -variable;
155
+ }
156
+ case "Next":
157
+ return getVariable(nexts, normal.body);
158
+ case "And": {
159
+ const variable = createVariable();
160
+ normal.children.forEach((child) => clauses.push([-variable, encode(child)]));
161
+ return variable;
162
+ }
163
+ case "Or": {
164
+ const variable = createVariable();
165
+ clauses.push([-variable, ...normal.children.map(encode)]);
166
+ return variable;
167
+ }
168
+ case "Always": {
169
+ const variable = createVariable();
170
+ clauses.push([-variable, encode(normal.body)], [-variable, getVariable(nexts, formula)]);
171
+ return variable;
172
+ }
173
+ case "Eventually": {
174
+ const variable = createVariable();
175
+ const body = encode(normal.body);
176
+ const next = getVariable(nexts, formula);
177
+ clauses.push([-variable, body, next], [-next, body, getVariable(pendings, formula)]);
178
+ return variable;
179
+ }
180
+ }
181
+ })();
182
+ literals.set(formula, literal);
183
+ return literal;
184
+ };
185
+ formulas.forEach((formula) => clauses.push([encode(formula)]));
186
+ const choices = [...nexts.values(), ...pendings.values()];
187
+ const solver = createSolver(counter.value, isExpired);
188
+ clauses.forEach(solver.addClause);
189
+ const steps: Step[] = [];
190
+ for (;;) {
191
+ const model = solver.solve([]);
192
+ if (typeof model === "string") return model === "unsat" ? steps : undefined;
193
+ // Drops each chosen variable that a model with no other choice can do without. A variable one
194
+ // pass keeps stays needed as the set shrinks, so the set that remains is minimal.
195
+ const minimal = choices.reduce<Int8Array | undefined>((current, choice) => {
196
+ if (current?.[choice] !== 1) return current;
197
+ const unchosen = choices.filter((other) => current[other] !== 1);
198
+ const smaller = solver.solve([-choice, ...unchosen.map((other) => -other)]);
199
+ if (smaller === "unknown") return undefined;
200
+ return smaller === "unsat" ? current : smaller;
201
+ }, model);
202
+ if (!minimal) return undefined;
203
+ const isChosen = (variable: number) => minimal[variable] === 1;
204
+ steps.push({
205
+ next: [...nexts].flatMap((entry) => (isChosen(entry[1]) ? [entry[0]] : [])),
206
+ pending: [...pendings].flatMap((entry) => (isChosen(entry[1]) ? [entry[0]] : [])),
207
+ });
208
+ solver.addClause(choices.filter(isChosen).map((choice) => -choice));
209
+ }
210
+ };
211
+
212
+ // Whether the formula is satisfiable, or unknown once isExpired turns true.
213
+ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean): Verdict => {
214
+ const table = createTable();
215
+ const nodes: number[][] = [];
216
+ const numbers = new Map<string, number>();
217
+ const getNode = (formulas: number[]) => {
218
+ const sorted = [...new Set(formulas)].sort((left, right) => left - right);
219
+ const key = sorted.join(",");
220
+ const existing = numbers.get(key);
221
+ if (existing !== undefined) return existing;
222
+ numbers.set(key, nodes.length);
223
+ nodes.push(sorted);
224
+ return nodes.length - 1;
225
+ };
226
+ getNode([table.normalize(formula, false)]);
227
+ const edges: Edge[][] = [];
228
+ for (let node = 0; node < nodes.length; node++) {
229
+ const steps = isExpired() ? undefined : getSteps(table.normals, nodes[node], isExpired);
230
+ if (!steps) return "unknown";
231
+ edges.push(steps.map((step) => ({ target: getNode(step.next), pending: step.pending })));
232
+ }
233
+ // Tarjan's algorithm, checking each component as it closes.
234
+ const indices = new Int32Array(nodes.length).fill(-1);
235
+ const lowlinks = new Int32Array(nodes.length);
236
+ const components = new Int32Array(nodes.length).fill(-1);
237
+ const stack: number[] = [];
238
+ const counter = { index: 0, component: 0 };
239
+ const isFair = (component: number) => {
240
+ const inner = edges.flatMap((outgoing, source) =>
241
+ components[source] === component
242
+ ? outgoing.filter((edge) => components[edge.target] === component)
243
+ : [],
244
+ );
245
+ if (inner.length === 0) return false;
246
+ const unfulfilled = inner
247
+ .slice(1)
248
+ .reduce(
249
+ (always, edge) => always.filter((eventuality) => edge.pending.includes(eventuality)),
250
+ inner[0].pending,
251
+ );
252
+ return unfulfilled.length === 0;
253
+ };
254
+ const visit = (node: number): boolean => {
255
+ indices[node] = counter.index;
256
+ lowlinks[node] = counter.index;
257
+ counter.index++;
258
+ stack.push(node);
259
+ for (const edge of edges[node]) {
260
+ if (indices[edge.target] === -1) {
261
+ if (visit(edge.target)) return true;
262
+ lowlinks[node] = Math.min(lowlinks[node], lowlinks[edge.target]);
263
+ } else if (components[edge.target] === -1) {
264
+ lowlinks[node] = Math.min(lowlinks[node], indices[edge.target]);
265
+ }
266
+ }
267
+ if (lowlinks[node] !== indices[node]) return false;
268
+ const component = counter.component++;
269
+ for (let member = stack.pop(); member !== undefined; member = stack.pop()) {
270
+ components[member] = component;
271
+ if (member === node) break;
272
+ }
273
+ return isFair(component);
274
+ };
275
+ return visit(0) ? "sat" : "unsat";
276
+ };
@@ -0,0 +1,69 @@
1
+ // encode/n_axiomatize.ml: the symbols and axioms an encoding needs.
2
+
3
+ import { compareStrings } from "../ocaml";
4
+ import { getSymbolSpec, type CollectState, type SymbolSpec } from "./data";
5
+ import type { Entry, Flattened } from "./flatten";
6
+ import { getTlaName } from "./format";
7
+ import { getAxiomKey, type Axiom } from "./table";
8
+
9
+ // N_axiomatize.collect: each symbol the obligation uses, in the order tlapm visits them, brings
10
+ // the symbols and axioms it depends on, smallest name first.
11
+ export const collectSymbols = (
12
+ entries: Entry[],
13
+ flattened: Map<string, Flattened>,
14
+ anonymous: Map<string, number>,
15
+ recordFields: Map<string, string[]>,
16
+ ) => {
17
+ const state: CollectState = {
18
+ recordFields,
19
+ strings: [],
20
+ isFunConstr: false,
21
+ isFunSet: false,
22
+ isExcept: false,
23
+ tuples: [],
24
+ records: [],
25
+ anonymous,
26
+ };
27
+ const symbols = new Map<string, SymbolSpec>();
28
+ const axioms = new Map<string, Axiom>();
29
+ const add = (name: string) => {
30
+ const work = new Set([name]);
31
+ while (work.size > 0) {
32
+ const next = [...work].toSorted(compareStrings)[0];
33
+ work.delete(next);
34
+ if (symbols.has(next)) continue;
35
+ const spec = getSymbolSpec(next, state);
36
+ symbols.set(next, spec);
37
+ spec.deps.forEach((dep) => work.add(dep));
38
+ spec.axioms.forEach((entry) => axioms.set(getAxiomKey(entry), entry));
39
+ }
40
+ };
41
+ // A flattened symbol stands for a builtin applied to its first-order arguments and then its
42
+ // higher-order ones, so its higher-order text is visited after its arguments.
43
+ const visit = (text: string) => {
44
+ const tokens = text.match(/[()]|[^\s()]+/g) ?? [];
45
+ const pending: { depth: number; text: string }[] = [];
46
+ tokens.reduce((depth, token, index) => {
47
+ if (token === "(") return depth + 1;
48
+ if (token === ")") {
49
+ if (pending.at(-1)?.depth === depth) visit(pending.pop()?.text ?? "");
50
+ return depth - 1;
51
+ }
52
+ const flat = flattened.get(token);
53
+ if (!flat) {
54
+ const builtin = getTlaName(token);
55
+ if (builtin !== undefined) add(builtin);
56
+ return depth;
57
+ }
58
+ if (flat.kind !== "") add(flat.kind);
59
+ if (tokens[index - 1] === "(") pending.push({ depth, text: flat.visit });
60
+ else visit(flat.visit);
61
+ return depth;
62
+ }, 0);
63
+ };
64
+ entries.forEach((entry) => {
65
+ if (typeof entry === "string") visit(entry);
66
+ else if ("omitted" in entry) visit(entry.omitted);
67
+ });
68
+ return { symbols, axioms };
69
+ };
@@ -0,0 +1,210 @@
1
+ // encode/n_axioms.ml: the formulas of the axioms that depend on a count or on fields.
2
+
3
+ import {
4
+ call,
5
+ CAST_INT,
6
+ conjoin,
7
+ disjoin,
8
+ forall,
9
+ FUN_APP,
10
+ FUN_DOM,
11
+ FUN_EXCEPT,
12
+ FUN_ISAFCN,
13
+ getNames,
14
+ LEN,
15
+ MEM,
16
+ SEQ,
17
+ tla,
18
+ } from "./format";
19
+ import { axiom, TYPED_SYMBOLS, type Axiom, type AxiomArgument } from "./table";
20
+
21
+ export const getTyping = (name: string, operator: string, arity: number, isGuarded = false) => {
22
+ const symbol = tla(name);
23
+ const variables = arity === 1 ? ["x1"] : isGuarded ? ["x", "y"] : ["x1", "x2"];
24
+ const left = call(
25
+ symbol,
26
+ variables.map((variable) => `(${CAST_INT} ${variable})`),
27
+ );
28
+ const right =
29
+ operator === "<="
30
+ ? `(<= ${variables.join(" ")})`
31
+ : `(${CAST_INT} (${operator} ${variables.join(" ")}))`;
32
+ const equality = `(= ${left} ${right})`;
33
+ return axiom(
34
+ "Typing",
35
+ [TYPED_SYMBOLS.indexOf(`T${name}`)],
36
+ forall(variables, isGuarded ? `(=> (> y 0) ${equality})` : equality, [[left]], "Int"),
37
+ `Typing T${name}`,
38
+ );
39
+ };
40
+
41
+ export const TYPINGS: Record<string, () => Axiom> = {
42
+ IntPlus: () => getTyping("IntPlus", "+", 2),
43
+ IntMinus: () => getTyping("IntMinus", "-", 2),
44
+ IntTimes: () => getTyping("IntTimes", "*", 2),
45
+ IntUminus: () => getTyping("IntUminus", "-", 1),
46
+ IntQuotient: () => getTyping("IntQuotient", "div", 2, true),
47
+ IntRemainder: () => getTyping("IntRemainder", "mod", 2, true),
48
+ IntLteq: () => getTyping("IntLteq", "<=", 2),
49
+ };
50
+
51
+ export const getEnumeration = (count: number) => {
52
+ const symbol = tla(`SetEnum_${count}`);
53
+ const elements = getNames("a", count);
54
+ const set = call(symbol, elements);
55
+ const elim = axiom(
56
+ "EnumDefElim",
57
+ [count],
58
+ forall(
59
+ [...elements, "x"],
60
+ count === 0
61
+ ? `(not (${MEM} x ${set}))`
62
+ : `(=> (${MEM} x ${set}) ${disjoin(elements.map((element) => `(= x ${element})`))})`,
63
+ [[`(${MEM} x ${set})`]],
64
+ ),
65
+ );
66
+ if (count === 0) return [elim];
67
+ const intro = axiom(
68
+ "EnumDefIntro",
69
+ [count],
70
+ forall(elements, conjoin(elements.map((element) => `(${MEM} ${element} ${set})`)), [[set]]),
71
+ );
72
+ return [intro, elim];
73
+ };
74
+
75
+ export const getIntegers = (count: number) =>
76
+ Array.from({ length: count }, (_value, index) => `(${CAST_INT} ${index + 1})`);
77
+
78
+ // TupExcept and RecExcept: updating one component of a tuple or record.
79
+ export const getComponentExcept = (
80
+ name: string,
81
+ args: AxiomArgument[],
82
+ symbol: string,
83
+ keys: string[],
84
+ index: number,
85
+ ) => {
86
+ const elements = getNames("x", keys.length);
87
+ const updated = `(${FUN_EXCEPT} ${call(symbol, elements)} ${keys[index]} x)`;
88
+ const replaced = elements.map((element, position) => (position === index ? "x" : element));
89
+ return axiom(
90
+ name,
91
+ [...args, index + 1],
92
+ forall([...elements, "x"], `(= ${updated} ${call(symbol, replaced)})`, [[updated]]),
93
+ );
94
+ };
95
+
96
+ export const getTupleAxioms = (count: number, isExcept: boolean) => {
97
+ const symbol = tla(`Tuple_${count}`);
98
+ const elements = getNames("x", count);
99
+ const value = call(symbol, elements);
100
+ const keys = getIntegers(count);
101
+ return [
102
+ axiom("TupIsafcn", [count], forall(elements, `(${FUN_ISAFCN} ${value})`, [[value]])),
103
+ ...(count === 0
104
+ ? []
105
+ : [
106
+ axiom(
107
+ "TupDomDef",
108
+ [count],
109
+ forall(elements, `(= (${FUN_DOM} ${value}) ${call(tla(`SetEnum_${count}`), keys)})`, [
110
+ [value],
111
+ ]),
112
+ ),
113
+ axiom(
114
+ "TupAppDef",
115
+ [count],
116
+ forall(
117
+ elements,
118
+ conjoin(
119
+ keys.map((key, index) => `(= (${FUN_APP} ${value} ${key}) ${elements[index]})`),
120
+ ),
121
+ [[value]],
122
+ ),
123
+ ),
124
+ ]),
125
+ axiom(
126
+ "SeqTupTyping",
127
+ [count],
128
+ forall(
129
+ ["a", ...elements],
130
+ count === 0
131
+ ? `(${MEM} ${value} (${SEQ} a))`
132
+ : `(=> ${conjoin(elements.map((element) => `(${MEM} ${element} a)`))} (${MEM} ${value} (${SEQ} a)))`,
133
+ [[...elements.map((element) => `(${MEM} ${element} a)`), value]],
134
+ ),
135
+ ),
136
+ axiom(
137
+ "SeqTupLen",
138
+ [count],
139
+ forall(elements, `(= (${LEN} ${value}) (${CAST_INT} ${count}))`, [[value]]),
140
+ ),
141
+ ...(isExcept
142
+ ? keys.map((_key, index) => getComponentExcept("TupExcept", [count], symbol, keys, index))
143
+ : []),
144
+ ];
145
+ };
146
+
147
+ export const getRecordAxioms = (fields: string[], isExcept: boolean) => {
148
+ const symbol = tla(`Record_${fields.join("_")}`);
149
+ const keys = fields.map((field) => tla(`StrLit_${field}`));
150
+ const elements = getNames("x", fields.length);
151
+ const value = call(symbol, elements);
152
+ return [
153
+ axiom("RecIsafcn", [fields], forall(elements, `(${FUN_ISAFCN} ${value})`, [[value]])),
154
+ axiom(
155
+ "RecDomDef",
156
+ [fields],
157
+ forall(elements, `(= (${FUN_DOM} ${value}) ${call(tla(`SetEnum_${fields.length}`), keys)})`, [
158
+ [value],
159
+ ]),
160
+ ),
161
+ axiom(
162
+ "RecAppDef",
163
+ [fields],
164
+ forall(
165
+ elements,
166
+ conjoin(keys.map((key, index) => `(= (${FUN_APP} ${value} ${key}) ${elements[index]})`)),
167
+ [[value]],
168
+ ),
169
+ ),
170
+ ...(isExcept
171
+ ? keys.map((_key, index) => getComponentExcept("RecExcept", [fields], symbol, keys, index))
172
+ : []),
173
+ ];
174
+ };
175
+
176
+ // The set of tuples or records whose components are in the given sets.
177
+ export const getComponentSet = (
178
+ name: string,
179
+ args: AxiomArgument[],
180
+ set: string,
181
+ value: string,
182
+ keys: string[],
183
+ variable: string,
184
+ ) => {
185
+ const sets = getNames("s", keys.length);
186
+ const elements = getNames("x", keys.length);
187
+ const members = call(set, sets);
188
+ const built = call(value, elements);
189
+ const projections = keys.map((key) => `(${FUN_APP} ${variable} ${key})`);
190
+ return [
191
+ axiom(
192
+ `${name}Intro`,
193
+ args,
194
+ forall(
195
+ [...sets, ...elements],
196
+ `(=> ${conjoin(elements.map((element, index) => `(${MEM} ${element} ${sets[index]})`))} (${MEM} ${built} ${members}))`,
197
+ [[built, members]],
198
+ ),
199
+ ),
200
+ axiom(
201
+ `${name}Elim`,
202
+ args,
203
+ forall(
204
+ [...sets, variable],
205
+ `(=> (${MEM} ${variable} ${members}) ${conjoin([`(= ${variable} ${call(value, projections)})`, ...projections.map((projection, index) => `(${MEM} ${projection} ${sets[index]})`)])})`,
206
+ [[`(${MEM} ${variable} ${members})`]],
207
+ ),
208
+ ),
209
+ ];
210
+ };
@@ -0,0 +1,108 @@
1
+ // ctx.ml and backend/smtlib.ml's naming: each name is salted past the names in scope.
2
+
3
+ import { formatName } from "./format";
4
+
5
+ // A quantifier's variables, in scope until the quantifier's closing parenthesis.
6
+ interface QuantifierScope {
7
+ depth: number;
8
+ exits: (() => void)[];
9
+ }
10
+
11
+ export interface Identifier {
12
+ base: string;
13
+ salt: number;
14
+ name: string;
15
+ }
16
+
17
+ const getSaltedName = (base: string, salt: number) => (salt === 0 ? base : `${base}_${salt}`);
18
+
19
+ // Ctx.maybe_adj: a name is its formatted base, salted past the last one with that base and past
20
+ // every name in scope.
21
+ export const createContext = () => {
22
+ const salts = new Map<string, number>();
23
+ const names = new Set<string>();
24
+ const adjoin = (raw: string): Identifier => {
25
+ const base = formatName(raw);
26
+ const start = (salts.get(base) ?? -1) + 1;
27
+ const salt =
28
+ Array.from({ length: names.size + 1 }, (_value, index) => start + index).find(
29
+ (candidate) => !names.has(getSaltedName(base, candidate)),
30
+ ) ?? start;
31
+ return { base, salt, name: getSaltedName(base, salt) };
32
+ };
33
+ // Brings an identifier into scope and returns how to take it out again.
34
+ const enter = (identifier: Identifier) => {
35
+ const previous = salts.get(identifier.base);
36
+ salts.set(identifier.base, identifier.salt);
37
+ names.add(identifier.name);
38
+ return () => {
39
+ names.delete(identifier.name);
40
+ if (previous === undefined) salts.delete(identifier.base);
41
+ else salts.set(identifier.base, previous);
42
+ };
43
+ };
44
+ return { names, adjoin, enter };
45
+ };
46
+
47
+ // Smtlib.pp_print_obligation names each declaration for the rest of the obligation, and each
48
+ // quantifier's variables within it, so a variable's name depends on the names in scope.
49
+ export const createPrinter = (declared: Map<string, Identifier>) => {
50
+ const context = createContext();
51
+ const resolve = (line: string) => {
52
+ const declaration = /^\(declare-fun (\S+)/.exec(line)?.[1];
53
+ if (declaration !== undefined) {
54
+ const identifier = declared.get(declaration);
55
+ if (identifier) context.enter(identifier);
56
+ else context.names.add(declaration);
57
+ return line;
58
+ }
59
+ const tokens = [...line.matchAll(/\|[^|]*\||[()]|[^\s()|]+/g)];
60
+ const replacements = new Map<number, string>();
61
+ const renames = new Map<string, string[]>();
62
+ const scopes: QuantifierScope[] = [];
63
+ const state = { index: 0, depth: 0 };
64
+ while (state.index < tokens.length) {
65
+ const token = tokens[state.index][0];
66
+ const isQuantifier =
67
+ token === "(" &&
68
+ (tokens[state.index + 1]?.[0] === "forall" || tokens[state.index + 1]?.[0] === "exists") &&
69
+ tokens[state.index + 2]?.[0] === "(";
70
+ if (isQuantifier) {
71
+ state.depth++;
72
+ const scope: QuantifierScope = { depth: state.depth, exits: [] };
73
+ scopes.push(scope);
74
+ state.index += 3;
75
+ while (tokens[state.index]?.[0] === "(") {
76
+ const raw = tokens[state.index + 1][0];
77
+ const identifier = context.adjoin(raw.replace(/#\d+$/, ""));
78
+ const stack = renames.get(raw) ?? [];
79
+ renames.set(raw, [...stack, identifier.name]);
80
+ scope.exits.push(context.enter(identifier), () => renames.set(raw, stack));
81
+ replacements.set(state.index + 1, identifier.name);
82
+ state.index += 4;
83
+ }
84
+ state.index++;
85
+ continue;
86
+ }
87
+ if (token === "(") state.depth++;
88
+ if (token === ")") {
89
+ if (scopes.at(-1)?.depth === state.depth)
90
+ scopes
91
+ .pop()
92
+ ?.exits.toReversed()
93
+ .forEach((exit) => exit());
94
+ state.depth--;
95
+ }
96
+ const name = renames.get(token)?.at(-1);
97
+ if (name !== undefined) replacements.set(state.index, name);
98
+ state.index++;
99
+ }
100
+ return tokens
101
+ .map((match, index) => {
102
+ const end = tokens[index + 1]?.index ?? line.length;
103
+ return `${replacements.get(index) ?? match[0]}${line.slice(match.index + match[0].length, end)}`;
104
+ })
105
+ .join("");
106
+ };
107
+ return { resolve };
108
+ };