solve-engine 1.1.1 → 2.0.0

package/dist/testing.js

@@ -1,470 +1,4 @@
-import { ExpressionEngine, checkPackageCompatibility, checkEngineVersionCompatibility } from './chunk-NNZAEUDW.js';
-import './chunk-I4GAWIPW.js';
-import './chunk-2RWAXT6O.js';
-import './chunk-3VGDNEE3.js';
-import './chunk-FD5ZZHEU.js';
-import './chunk-WXEHD6TT.js';
-import './chunk-CCBZZQAE.js';
-import './chunk-3OWCDIPN.js';
-import './chunk-UKQHXPGW.js';
-import { BUILTIN_PACKAGES } from './chunk-4HQKTMWG.js';
-import './chunk-ENKKJYD3.js';
-import './chunk-BYJBUL7U.js';
-import './chunk-3BOK2LDK.js';
-import './chunk-7KYSUDQO.js';
-import './chunk-NLNDMWZC.js';
-import './chunk-NKW7LKYU.js';
-import './chunk-GCM5JHMX.js';
-import './chunk-Z7XGGLI2.js';
-import './chunk-BLI4NIQY.js';
-import './chunk-Z4X2RWOF.js';
-import './chunk-5HRB36DK.js';
-import './chunk-NNQ2TYDF.js';
-import { Value } from './chunk-267JPOTF.js';
-import './chunk-MVTOCRV2.js';
-import { ENGINE_VERSION } from './chunk-GLA4JXBO.js';
-import './chunk-DLEBSLF4.js';
-import './chunk-UO6BUV6K.js';
-import './chunk-JG6ZJ2WU.js';
-import './chunk-4D6NIHE2.js';
-import './chunk-XBTEO4OB.js';
-import './chunk-SBUFNJVE.js';
-import './chunk-V4XG5QF6.js';
-import { EngineError } from './chunk-ERCOHGXD.js';
-import './chunk-YLJ4XMA6.js';
-
-// src/testing/index.ts
-var ExpectationError = class _ExpectationError extends Error {
-  constructor(init) {
-    super(init.message);
-    this.name = "ExpectationError";
-    this.code = init.code;
-    this.expected = init.expected;
-    this.actual = init.actual;
-    Object.setPrototypeOf(this, _ExpectationError.prototype);
-  }
-};
-function createTestEngine(packages = [], options = {}) {
-  const { locale = "en", includeBuiltins = true } = options;
-  const engine = new ExpressionEngine(locale, false, void 0, void 0, includeBuiltins ? BUILTIN_PACKAGES : []);
-  for (const pkg of packages) {
-    engine.registerPackage(pkg);
-  }
-  return engine;
-}
-function evaluate(engine, expression) {
-  try {
-    const [value] = engine.evaluateExpression(expression);
-    if (value === void 0) {
-      return {
-        status: "error",
-        code: "NO_RESULT",
-        message: "Evaluation returned no value.",
-        source: new Value(13 /* Error */, "NO_RESULT", "Evaluation returned no value.")
-      };
-    }
-    if (value.type === 13 /* Error */) {
-      return {
-        status: "error",
-        code: String(value.value),
-        message: typeof value.unit === "string" ? value.unit : "",
-        source: value
-      };
-    }
-    if (value.type === 12 /* Pending */) {
-      return { status: "pending", value };
-    }
-    return { status: "value", value };
-  } catch (error) {
-    if (error instanceof EngineError) {
-      return { status: "error", code: error.code, message: error.message, source: error };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      status: "error",
-      code: "UNKNOWN_ERROR",
-      message,
-      source: new Value(13 /* Error */, "UNKNOWN_ERROR", message)
-    };
-  }
-}
-function numbersEqual(a, b) {
-  if (Object.is(a, b)) return true;
-  if (!Number.isFinite(a) || !Number.isFinite(b)) return false;
-  const epsilon = 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
-  return Math.abs(a - b) <= epsilon;
-}
-function describeValue(value) {
-  if (value.type === 3 /* String */) return JSON.stringify(value.value);
-  if (value.type === 6 /* Uom */ && typeof value.unit === "string") {
-    return `${String(value.value)} ${value.unit}`;
-  }
-  return String(value.value);
-}
-function describeOutcome(outcome) {
-  switch (outcome.status) {
-    case "value":
-      return describeValue(outcome.value);
-    case "pending":
-      return "a pending async value";
-    case "error":
-      return `an error (${outcome.code}: ${outcome.message})`;
-  }
-}
-var ExpressionAssertion = class {
-  constructor(expression, outcome) {
-    this.expression = expression;
-    this.outcome = outcome;
-  }
-  /** The raw resolved {@link Value}, for an assertion the matchers do not cover. Throws if the expression failed. */
-  get value() {
-    if (this.outcome.status === "error") {
-      throw new ExpectationError({
-        code: "EXPECTED_VALUE",
-        message: `Expected "${this.expression}" to evaluate, but it failed with ${describeOutcome(this.outcome)}.`,
-        expected: "a resolved value",
-        actual: describeOutcome(this.outcome)
-      });
-    }
-    return this.outcome.value;
-  }
-  /**
-   * Assert the expression evaluated to a value (not an error, not a pending
-   * async result). Says nothing about what the value is.
-   */
-  toEvaluate() {
-    if (this.outcome.status !== "value") {
-      throw new ExpectationError({
-        code: "EXPECTED_EVALUATE",
-        message: `Expected "${this.expression}" to evaluate to a value, but got ${describeOutcome(this.outcome)}.`,
-        expected: "a resolved value",
-        actual: describeOutcome(this.outcome)
-      });
-    }
-    return this;
-  }
-  /**
-   * Assert the expression evaluated to `expected`, and, when `unit` is given,
-   * that the result carries exactly that unit. A number compares against the
-   * value's numeric magnitude within a small floating-point tolerance; a
-   * string compares against the value's own string; a boolean against its
-   * boolean reading. Omitting `unit` leaves the unit unchecked, so
-   * `toEqual(5)` passes for both `5` and `5 gp`.
-   */
-  toEqual(expected, unit) {
-    if (this.outcome.status !== "value") {
-      throw new ExpectationError({
-        code: "EXPECTED_EQUAL",
-        message: `Expected "${this.expression}" to equal ${describeExpected(expected, unit)}, but got ${describeOutcome(this.outcome)}.`,
-        expected: describeExpected(expected, unit),
-        actual: describeOutcome(this.outcome)
-      });
-    }
-    const value = this.outcome.value;
-    let matches;
-    if (typeof expected === "number") {
-      matches = numbersEqual(value.toNumber(), expected);
-    } else if (typeof expected === "boolean") {
-      matches = value.type === 10 /* Boolean */ && value.value === expected;
-    } else {
-      matches = valueToComparableString(value) === expected;
-    }
-    if (!matches) {
-      throw new ExpectationError({
-        code: "EXPECTED_EQUAL",
-        message: `Expected "${this.expression}" to equal ${describeExpected(expected, unit)}, but it was ${describeValue(value)}.`,
-        expected: describeExpected(expected, unit),
-        actual: describeValue(value)
-      });
-    }
-    if (unit !== void 0 && value.unit !== unit) {
-      throw new ExpectationError({
-        code: "EXPECTED_UNIT",
-        message: `Expected "${this.expression}" to carry the unit "${unit}", but it was ${value.unit === void 0 ? "unitless" : `"${value.unit}"`}.`,
-        expected: `unit "${unit}"`,
-        actual: value.unit === void 0 ? "no unit" : `unit "${value.unit}"`
-      });
-    }
-    return this;
-  }
-  /** Assert the expression failed (a thrown engine error or a plugin-raised error value). Says nothing about the code. */
-  toBeError() {
-    if (this.outcome.status !== "error") {
-      throw new ExpectationError({
-        code: "EXPECTED_ERROR",
-        message: `Expected "${this.expression}" to fail, but it produced ${describeOutcome(this.outcome)}.`,
-        expected: "an error",
-        actual: describeOutcome(this.outcome)
-      });
-    }
-    return this;
-  }
-  /**
-   * Assert the expression failed with exactly `code`, the error catalog code
-   * (e.g. `"UNDEFINED_VARIABLE"`, or a package's own code). Reports the code
-   * it actually got when they differ, so a near-miss is obvious.
-   */
-  toFailWith(code) {
-    if (this.outcome.status !== "error") {
-      throw new ExpectationError({
-        code: "EXPECTED_FAIL_WITH",
-        message: `Expected "${this.expression}" to fail with "${code}", but it produced ${describeOutcome(this.outcome)}.`,
-        expected: `error code "${code}"`,
-        actual: describeOutcome(this.outcome)
-      });
-    }
-    if (this.outcome.code !== code) {
-      throw new ExpectationError({
-        code: "EXPECTED_FAIL_WITH",
-        message: `Expected "${this.expression}" to fail with "${code}", but it failed with "${this.outcome.code}" (${this.outcome.message}).`,
-        expected: `error code "${code}"`,
-        actual: `error code "${this.outcome.code}"`
-      });
-    }
-    return this;
-  }
-  /**
-   * Assert the expression returned a value still resolving asynchronously.
-   * The kit evaluates synchronously, so a package whose result comes from an
-   * async resolver reports pending on first evaluation, this is how a test
-   * confirms the async path was taken without resolving it.
-   */
-  toBePending() {
-    if (this.outcome.status !== "pending") {
-      throw new ExpectationError({
-        code: "EXPECTED_PENDING",
-        message: `Expected "${this.expression}" to be pending, but got ${describeOutcome(this.outcome)}.`,
-        expected: "a pending async value",
-        actual: describeOutcome(this.outcome)
-      });
-    }
-    return this;
-  }
-};
-function describeExpected(expected, unit) {
-  const base = typeof expected === "string" ? JSON.stringify(expected) : String(expected);
-  return unit === void 0 ? base : `${base} ${unit}`;
-}
-function valueToComparableString(value) {
-  return String(value.value);
-}
-function expectExpression(engine, expression) {
-  return new ExpressionAssertion(expression, evaluate(engine, expression));
-}
-var COMMON_PROSE_WORDS = [
-  "a",
-  "an",
-  "and",
-  "or",
-  "but",
-  "if",
-  "then",
-  "the",
-  "this",
-  "that",
-  "these",
-  "those",
-  "in",
-  "on",
-  "at",
-  "to",
-  "of",
-  "for",
-  "from",
-  "with",
-  "by",
-  "as",
-  "per",
-  "into",
-  "over",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "do",
-  "does",
-  "did",
-  "have",
-  "has",
-  "had",
-  "will",
-  "would",
-  "can",
-  "could",
-  "should",
-  "may",
-  "might",
-  "must",
-  "price",
-  "cost",
-  "value",
-  "total",
-  "sum",
-  "count",
-  "rate",
-  "amount",
-  "number",
-  "time",
-  "date",
-  "day",
-  "week",
-  "month",
-  "year",
-  "hour",
-  "minute",
-  "second",
-  "add",
-  "buy",
-  "sell",
-  "hold",
-  "make",
-  "take",
-  "give",
-  "get",
-  "set",
-  "run",
-  "up",
-  "down",
-  "out",
-  "off",
-  "all",
-  "some",
-  "any",
-  "no",
-  "not",
-  "more",
-  "less",
-  "one",
-  "two",
-  "three",
-  "first",
-  "last",
-  "next",
-  "each",
-  "every",
-  "here",
-  "there"
-];
-var SEVERITY_ORDER = ["error", "warning", "info"];
-function claimedWords(pkg) {
-  const claimed = [];
-  const vocab = pkg.lexerVocabulary;
-  if (vocab?.keywords) {
-    for (const [word, tokenType] of Object.entries(vocab.keywords)) {
-      claimed.push({ word, via: "keyword", tokenType });
-    }
-  }
-  if (vocab?.units) {
-    for (const word of vocab.units) {
-      claimed.push({ word, via: "unit" });
-    }
-  }
-  if (vocab?.operators) {
-    for (const [word, tokenType] of Object.entries(vocab.operators)) {
-      claimed.push({ word, via: "operator", tokenType });
-    }
-  }
-  if (pkg.phrases) {
-    for (const [phrase, tokenType] of Object.entries(pkg.phrases)) {
-      if (!phrase.includes(" ")) {
-        claimed.push({ word: phrase, via: "phrase", tokenType });
-      }
-    }
-  }
-  return claimed;
-}
-var PackageAssertion = class {
-  constructor(pkg) {
-    this.pkg = pkg;
-  }
-  /**
-   * Assert none of the package's claimed words shadow a prose word.
-   *
-   * A trigger word that is also an ordinary word turns a line of prose into
-   * arithmetic, the single most common package mistake and the subject of the
-   * trigger-words guide. This checks the words the package declares
-   * (lexer keywords, units, operators, and single-word phrases) against
-   * `words` (defaulting to {@link COMMON_PROSE_WORDS}), case-insensitively.
-   *
-   * @returns the shadowed words, empty when the package is clean, for a test
-   * that wants to inspect rather than assert.
-   */
-  notToShadow(words = COMMON_PROSE_WORDS) {
-    const prose = new Set(words.map((w) => w.toLowerCase()));
-    const shadowed = claimedWords(this.pkg).filter((c) => prose.has(c.word.toLowerCase()));
-    if (shadowed.length > 0) {
-      const list = shadowed.map((s) => `"${s.word}" (${s.via})`).join(", ");
-      throw new ExpectationError({
-        code: "PACKAGE_SHADOWS_PROSE",
-        message: `Package "${this.pkg.name}" claims prose word(s) as syntax: ${list}. A word that is also ordinary English turns prose into arithmetic; prefer a multi-word phrase or a form that requires a parenthesis.`,
-        expected: "no prose words claimed as syntax",
-        actual: list
-      });
-    }
-    return shadowed;
-  }
-  /**
-   * Assert the package does not collide with any of `others` in a way that
-   * would silently break one of them (two packages claiming the same lexer
-   * keyword, plugin-function index, async-resolver namespace, and so on).
-   *
-   * `strictness` sets which severities fail the assertion: `"error"` (the
-   * default) fails only on the collisions that always break something,
-   * `"warning"` also fails on the ones that silently pick a winner, `"info"`
-   * fails on cosmetic overlaps too.
-   *
-   * @returns the full compatibility report, so a test can inspect every
-   * conflict, including ones below the strictness threshold.
-   */
-  notToCollideWith(others, strictness = "error") {
-    const report = checkPackageCompatibility(this.pkg, others);
-    const threshold = SEVERITY_ORDER.indexOf(strictness);
-    const failing = report.conflicts.filter(
-      (c) => SEVERITY_ORDER.indexOf(c.severity) <= threshold
-    );
-    if (failing.length > 0) {
-      const list = failing.map((c) => `[${c.severity}] ${c.detail}`).join("\n");
-      throw new ExpectationError({
-        code: "PACKAGE_VOCABULARY_COLLISION",
-        message: `Package "${this.pkg.name}" collides with another package:
-${list}`,
-        expected: `no conflicts at or above "${strictness}" severity`,
-        actual: `${failing.length} conflict(s)`
-      });
-    }
-    return report;
-  }
-  /**
-   * Assert the package's declared `engineVersion` range is satisfied by the
-   * running engine (or by `engineVersion` when given).
-   *
-   * A package that declares a range and never checks it resolves is the third
-   * mistake the issue names: it looks fine until the one engine version it
-   * cannot run against, where the range either fails to match or turns out to
-   * be a malformed string. A package with no declared range passes (no
-   * constraint is always compatible).
-   */
-  toDeclareCompatibleEngineVersion(engineVersion = ENGINE_VERSION) {
-    const result = checkEngineVersionCompatibility(this.pkg, engineVersion);
-    if (!result.compatible) {
-      const detail = result.reason === "invalid-range" ? `its range "${result.declaredRange}" is not valid semver` : `its range "${result.declaredRange}" is not satisfied by engine version "${result.engineVersion}"`;
-      throw new ExpectationError({
-        code: "PACKAGE_ENGINE_VERSION_INCOMPATIBLE",
-        message: `Package "${this.pkg.name}" declares an engineVersion that will be rejected at registration: ${detail}.`,
-        expected: `an engineVersion satisfied by "${engineVersion}"`,
-        actual: `"${result.declaredRange}"`
-      });
-    }
-    return this;
-  }
-};
-function expectPackage(pkg) {
-  return new PackageAssertion(pkg);
-}
-
-export { COMMON_PROSE_WORDS, ExpectationError, ExpressionAssertion, PackageAssertion, createTestEngine, expectExpression, expectPackage };
-//# sourceMappingURL=testing.js.map
+import {n as n$1,a,b}from'./chunk-XR7HEC7B.js';import'./chunk-XNIWQHXY.js';import'./chunk-2RWAXT6O.js';import'./chunk-7GK3XEZF.js';import'./chunk-MIQBJGGR.js';import'./chunk-YJ2OPULK.js';import'./chunk-TWC7K3ZX.js';import'./chunk-J4LZD4ZY.js';import'./chunk-XEIDV5JP.js';import {y}from'./chunk-EYRBENHC.js';import'./chunk-6G3PMEPA.js';import'./chunk-6CY44ZPG.js';import'./chunk-YVKHEAFT.js';import'./chunk-QXQE7X4S.js';import'./chunk-76F3LCIL.js';import'./chunk-TCZSPH4A.js';import'./chunk-W2JAR233.js';import'./chunk-YAYBVVG2.js';import'./chunk-E6Z4NQAS.js';import'./chunk-HFKDWQUL.js';import'./chunk-R2ENWQ76.js';import'./chunk-RSF25YSJ.js';import {m}from'./chunk-EVAOPEO4.js';import'./chunk-WGZ3FNHI.js';import {a as a$1}from'./chunk-L3FPQSGN.js';import'./chunk-GOIQYUWV.js';import'./chunk-JPFCXLJV.js';import'./chunk-UI6IFGBT.js';import'./chunk-IJMNVBIS.js';import'./chunk-62LMTO4F.js';import'./chunk-TRBXW6HW.js';import'./chunk-2JMFUQZH.js';import {b as b$1}from'./chunk-MPB7KUN5.js';var i=class o extends Error{constructor(t){super(t.message),this.name="ExpectationError",this.code=t.code,this.expected=t.expected,this.actual=t.actual,Object.setPrototypeOf(this,o.prototype);}};function V(o=[],t={}){let{locale:e="en",includeBuiltins:r=true}=t,s=new n$1({locale:e,packages:r?y:[]});for(let a of o)s.registerPackage(a);return s}function v(o,t){try{let e=o.evaluateExpression(t);return e.isError()?{status:"error",code:e.errorCode??"",message:e.errorMessage??"",source:e}:e.isPending()?{status:"pending",value:e}:{status:"value",value:e}}catch(e){if(e instanceof b$1)return {status:"error",code:e.code,message:e.message,source:e};let r=e instanceof Error?e.message:String(e);return {status:"error",code:"UNKNOWN_ERROR",message:r,source:new m(13,"UNKNOWN_ERROR",r)}}}function x(o,t){if(Object.is(o,t))return  true;if(!Number.isFinite(o)||!Number.isFinite(t))return  false;let e=1e-9*Math.max(1,Math.abs(o),Math.abs(t));return Math.abs(o-t)<=e}function l(o){return o.type===3?JSON.stringify(o.value):o.type===6&&typeof o.unit=="string"?`${String(o.value)} ${o.unit}`:String(o.value)}function n(o){switch(o.status){case "value":return l(o.value);case "pending":return "a pending async value";case "error":return `an error (${o.code}: ${o.message})`}}var d=class{constructor(t,e){this.expression=t;this.outcome=e;}get value(){if(this.outcome.status==="error")throw new i({code:"EXPECTED_VALUE",message:`Expected "${this.expression}" to evaluate, but it failed with ${n(this.outcome)}.`,expected:"a resolved value",actual:n(this.outcome)});return this.outcome.value}toEvaluate(){if(this.outcome.status!=="value")throw new i({code:"EXPECTED_EVALUATE",message:`Expected "${this.expression}" to evaluate to a value, but got ${n(this.outcome)}.`,expected:"a resolved value",actual:n(this.outcome)});return this}toEqual(t,e){if(this.outcome.status!=="value")throw new i({code:"EXPECTED_EQUAL",message:`Expected "${this.expression}" to equal ${c(t,e)}, but got ${n(this.outcome)}.`,expected:c(t,e),actual:n(this.outcome)});let r=this.outcome.value,s;if(typeof t=="number"?s=x(r.toNumber(),t):typeof t=="boolean"?s=r.type===10&&r.value===t:s=C(r)===t,!s)throw new i({code:"EXPECTED_EQUAL",message:`Expected "${this.expression}" to equal ${c(t,e)}, but it was ${l(r)}.`,expected:c(t,e),actual:l(r)});if(e!==void 0&&r.unit!==e)throw new i({code:"EXPECTED_UNIT",message:`Expected "${this.expression}" to carry the unit "${e}", but it was ${r.unit===void 0?"unitless":`"${r.unit}"`}.`,expected:`unit "${e}"`,actual:r.unit===void 0?"no unit":`unit "${r.unit}"`});return this}toBeError(){if(this.outcome.status!=="error")throw new i({code:"EXPECTED_ERROR",message:`Expected "${this.expression}" to fail, but it produced ${n(this.outcome)}.`,expected:"an error",actual:n(this.outcome)});return this}toFailWith(t){if(this.outcome.status!=="error")throw new i({code:"EXPECTED_FAIL_WITH",message:`Expected "${this.expression}" to fail with "${t}", but it produced ${n(this.outcome)}.`,expected:`error code "${t}"`,actual:n(this.outcome)});if(this.outcome.code!==t)throw new i({code:"EXPECTED_FAIL_WITH",message:`Expected "${this.expression}" to fail with "${t}", but it failed with "${this.outcome.code}" (${this.outcome.message}).`,expected:`error code "${t}"`,actual:`error code "${this.outcome.code}"`});return this}toBePending(){if(this.outcome.status!=="pending")throw new i({code:"EXPECTED_PENDING",message:`Expected "${this.expression}" to be pending, but got ${n(this.outcome)}.`,expected:"a pending async value",actual:n(this.outcome)});return this}};function c(o,t){let e=typeof o=="string"?JSON.stringify(o):String(o);return t===void 0?e:`${e} ${t}`}function C(o){return String(o.value)}function D(o,t){return new d(t,v(o,t))}var O=["a","an","and","or","but","if","then","the","this","that","these","those","in","on","at","to","of","for","from","with","by","as","per","into","over","is","are","was","were","be","been","being","do","does","did","have","has","had","will","would","can","could","should","may","might","must","price","cost","value","total","sum","count","rate","amount","number","time","date","day","week","month","year","hour","minute","second","add","buy","sell","hold","make","take","give","get","set","run","up","down","out","off","all","some","any","no","not","more","less","one","two","three","first","last","next","each","every","here","there"],$=["error","warning","info"];function k(o){let t=[],e=o.lexerVocabulary;if(e?.keywords)for(let[r,s]of Object.entries(e.keywords))t.push({word:r,via:"keyword",tokenType:s});if(e?.units)for(let r of e.units)t.push({word:r,via:"unit"});if(e?.operators)for(let[r,s]of Object.entries(e.operators))t.push({word:r,via:"operator",tokenType:s});if(o.phrases)for(let[r,s]of Object.entries(o.phrases))r.includes(" ")||t.push({word:r,via:"phrase",tokenType:s});return t}var p=class{constructor(t){this.pkg=t;}notToShadow(t=O){let e=new Set(t.map(s=>s.toLowerCase())),r=k(this.pkg).filter(s=>e.has(s.word.toLowerCase()));if(r.length>0){let s=r.map(a=>`"${a.word}" (${a.via})`).join(", ");throw new i({code:"PACKAGE_SHADOWS_PROSE",message:`Package "${this.pkg.name}" claims prose word(s) as syntax: ${s}. A word that is also ordinary English turns prose into arithmetic; prefer a multi-word phrase or a form that requires a parenthesis.`,expected:"no prose words claimed as syntax",actual:s})}return r}notToCollideWith(t,e="error"){let r=a(this.pkg,t),s=$.indexOf(e),a$1=r.conflicts.filter(u=>$.indexOf(u.severity)<=s);if(a$1.length>0){let u=a$1.map(g=>`[${g.severity}] ${g.detail}`).join(`
+`);throw new i({code:"PACKAGE_VOCABULARY_COLLISION",message:`Package "${this.pkg.name}" collides with another package:
+${u}`,expected:`no conflicts at or above "${e}" severity`,actual:`${a$1.length} conflict(s)`})}return r}toDeclareCompatibleEngineVersion(t=a$1){let e=b(this.pkg,t);if(!e.compatible){let r=e.reason==="invalid-range"?`its range "${e.declaredRange}" is not valid semver`:`its range "${e.declaredRange}" is not satisfied by engine version "${e.engineVersion}"`;throw new i({code:"PACKAGE_ENGINE_VERSION_INCOMPATIBLE",message:`Package "${this.pkg.name}" declares an engineVersion that will be rejected at registration: ${r}.`,expected:`an engineVersion satisfied by "${t}"`,actual:`"${e.declaredRange}"`})}return this}};function L(o){return new p(o)}export{O as COMMON_PROSE_WORDS,i as ExpectationError,d as ExpressionAssertion,p as PackageAssertion,V as createTestEngine,D as expectExpression,L as expectPackage};//# sourceMappingURL=testing.js.map
 //# sourceMappingURL=testing.js.map