ata-validator 1.27.1 → 1.29.0

package/README.md

@@ -445,11 +445,14 @@ const v = new Validator(schema, {
   removeAdditional: true,  // strip properties not in schema
   schemas: [otherSchema],  // cross-schema $ref registry
   abortEarly: true,        // skip detailed error collection on failure (~4x faster on invalid data)
+  engine: 'interpreter',   // eval-free interpreted engine only: for a schema from outside the trust boundary
 });
 ```
 
 `abortEarly` returns a shared `{ valid: false, errors: [{ message: 'validation failed' }] }` on failure instead of running the detailed error collector. Useful when the caller only needs a pass/fail decision (Fastify route guards, high-throughput gatekeepers, request rejection at the edge).
 
+`engine: 'interpreter'` keeps one validator off code generation: no `new Function`, no shared compile cache, the interpreted engine answers every call. The default turns a schema into JavaScript source, which is the right trade for a schema you wrote; a schema that arrives at runtime from a plugin or a tenant is input, and this option validates against it without ever executing anything derived from it. Same verdict, higher per-call cost; `ATA_FORCE_NAPI=1` does the same for a whole process.
+
 ### Build-time compile (`ata compile`)
 
 The `ata` CLI turns a JSON Schema file into a self-contained JavaScript module. No runtime dependency on `ata-validator`, so only the generated validator ships to the browser. Typical output is about 4.5 KB gzipped for a ten-field schema, full error detail included, against 87 KB for the runtime bundled for the browser.
@@ -700,6 +703,9 @@ npm run test:suite
 
 ## Project
 
+- [CHANGELOG.md](CHANGELOG.md) records every release. It is kept in the
+  repository and not shipped in the npm package, where its history had grown to
+  about 13% of the install.
 - [CONTRIBUTING.md](CONTRIBUTING.md) explains how to build the project and what a
   pull request needs before it can be merged.
 - [GOVERNANCE.md](GOVERNANCE.md) says who decides what, which changes the project

package/build.d.ts

@@ -144,8 +144,10 @@ export function bundleCompact(schemas: unknown[], options?: BundleStandaloneOpti
  * Stable content hash of a schema, 16 hex characters, over a canonical JSON
  * form (keys sorted at every level). Every module from
  * {@link toStandaloneModule} exports its own `schemaHash`; comparing that
- * against `schemaHash(currentSchema)` tells a build the module is stale.
- * An integrity aid, not a security boundary.
+ * against `schemaHash(currentSchema)` tells a build the schema has changed.
+ * It does not tell the build that ata has changed, since an upgrade leaves
+ * the hash matching, so compare the module's `ataVersion` against the
+ * installed version as well. An integrity aid, not a security boundary.
  */
 export function schemaHash(schema: unknown): string;
 

package/index.d.ts

@@ -425,6 +425,17 @@ export interface ValidatorOptions {
    * v0.14 error shape.
    */
   richErrors?: boolean;
+  /**
+   * Which engine may answer this validator. 'auto' (default) picks the fastest
+   * engine that handles the schema, generated JavaScript for most schemas.
+   * 'interpreter' keeps the schema off code generation entirely: no
+   * `new Function`, no shared compile cache; the eval-free interpreted engine
+   * answers `validate()`, `isValidObject()` and `validateJSON()`. For a schema
+   * that arrives from outside the trust boundary. The verdict is the same on
+   * every engine; the cost is not. The buffer APIs (`isValid`, `countValid`,
+   * `batchIsValid`) are native-only and unaffected.
+   */
+  engine?: 'auto' | 'interpreter';
 }
 
 export interface BundleStandaloneOptions extends ValidatorOptions {
@@ -473,7 +484,7 @@ export interface Validator<T = unknown> {
    * Which engine answers `validate()` for this schema: 'codegen' (generated
    * JS), 'closure' (the closure compiler) or 'interpreter'; 'native' is
    * reserved. The verdict is the same on every engine; the cost is not.
-   * A diagnostic, not a configuration.
+   * A diagnostic; the `engine` option is the setting.
    */
   engine(): 'codegen' | 'closure' | 'native' | 'interpreter';
 

package/index.js

@@ -462,11 +462,18 @@ const { rankFor: schemaOrderRank, ordinalFor: schemaOrdinal } = require('./lib/s
 // that carry only message and path, such as the Standard Schema bridge.
 // Prototype accessors, not per-instance ones: see LazyRejection.
 class RichRejection {
-  constructor(result, data, positions, self, root, enrich) {
+  // `rawInput` is the JSON text validateJSON was given, or null for validate(data).
+  // The position map it implies is built in the `errors` getter, not here: it is
+  // a full walk of the document, it is only ever read through an error's
+  // dataFrame, and building it on every rejection cost a caller that reads
+  // `.valid` about 460 microseconds on a 50 KB document. Holding the text rather
+  // than reading `self._lastRawInput` later also keeps the result independent of
+  // what the instance does after this call returns.
+  constructor(result, data, rawInput, self, root, enrich) {
     this.valid = false;
     this._result = result;
     this._data = data;
-    this._positions = positions;
+    this._rawInput = rawInput;
     this._self = self;
     this._root = root;
     this._enrich = enrich;
@@ -490,11 +497,17 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
       const enrich = this._enrich;
       let raw = this._result.errors || [];
       if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+      // The position map, resolved now that an error is actually being read.
+      let positions = null;
+      if (enrich && raw.length && this._rawInput != null) {
+        positions = self._pos().get(this._rawInput);
+        if (positions) self._posCache.reset();
+      }
       // One options object for the whole list, not one per error.
       const opts = enrich && raw.length
         ? {
             data: this._data,
-            positions: this._positions,
+            positions,
             schemaPositions: self._schemaPositions,
             schemaFile: self._source ? self._source.path : undefined,
           }
@@ -518,6 +531,98 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
   },
 });
 
+// The rejection validateJSON returns. Everything the text path adds over
+// validate(data), the value tree enrichment needs, the position map, the
+// diagnostic payload, happens on first access to `.errors`. Reading `.valid`
+// touches none of it. The JSON text is held here rather than read back off the
+// validator, so the result does not depend on what the instance does next.
+class LazyJsonRejection {
+  constructor(result, jsonStr, self, enrich) {
+    this.valid = false;
+    this._result = result;
+    this._jsonStr = jsonStr;
+    this._self = self;
+    this._enrich = enrich;
+    this._cached = null;
+  }
+  toJSON() {
+    return { valid: false, errors: this.errors };
+  }
+}
+Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
+  enumerable: true,
+  configurable: true,
+  get() {
+    if (this._cached !== null) return this._cached;
+    const self = this._self;
+    const enrich = this._enrich;
+    const jsonStr = this._jsonStr;
+    // Reading the inner errors realizes the inner lazy layer, if there was one.
+    const raw = this._result.errors || [];
+    if (!raw.length) { this._cached = raw; return raw; }
+
+    // The enrich pass plucks `received` from the value tree and the suggestion
+    // engine (required-typo, format hints, coercion nudges) walks it too.
+    let parsedData;
+    try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
+
+    // Errors the inner path already enriched carry a docUrl: only enrich() sets
+    // one. `code` is not a safe signal, because branch-collapse attaches codes
+    // to raw errors, and detecting on it left every collapsed oneOf/anyOf error
+    // unenriched on the text path.
+    if (!raw[0] || !raw[0].docUrl) {
+      const positions = self._pos().get(jsonStr);
+      // Declaration order, as validate() applies it; the text path used to
+      // enrich in emission order.
+      const ordered = raw.length > 1 ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      const enrichOpts = {
+        data: parsedData,
+        positions,
+        schemaPositions: self._schemaPositions,
+        schemaFile: self._source ? self._source.path : undefined,
+      };
+      const enriched = ordered.map((e) => enrich(e, enrichOpts));
+      if (enriched.length > 1) attachRelated(enriched);
+      attachDiagnosticSource(enriched, {
+        data: parsedData,
+        text: jsonStr,
+        positions,
+        schema: self._schemaObj,
+        mutatesInput: self._mutatesInput === true,
+      });
+      if (positions) self._posCache.reset();
+      this._cached = enriched;
+      return enriched;
+    }
+
+    // Already enriched, so the frames are usually attached too. Only a gap in
+    // them is worth another walk of the document: resolving the map to discover
+    // there was nothing to fill cost a second full walk on every rejection.
+    if (raw.some((e) => e && !e.dataFrame)) {
+      const positions = self._pos().get(jsonStr);
+      if (positions) {
+        for (const e of raw) {
+          if (e && !e.dataFrame) {
+            const path = e.path != null ? e.path : (e.instancePath || '');
+            const p = positions[path];
+            if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
+          }
+        }
+        self._posCache.reset();
+      }
+    }
+    if (raw.length > 1) attachRelated(raw);
+    attachDiagnosticSource(raw, {
+      data: parsedData,
+      text: jsonStr,
+      schema: self._schemaObj,
+      mutatesInput: self._mutatesInput === true,
+    });
+    this._cached = raw;
+    return raw;
+  },
+});
+
 // A raw error without the `_o` ordering key, for the legacy error shape.
 function stripOrdinal(e) {
   if (e === null || typeof e !== 'object' || e._o === undefined) return e;
@@ -896,6 +1001,18 @@ class Validator {
     this._rawIsCallers = typeof schema !== "string";
     this._options = options;
     this._noOpts = !opts;
+    // engine: 'interpreter' keeps this validator off code generation: no
+    // `new Function`, no shared compile cache, the eval-free interpreted
+    // engine answers validate(), isValidObject() and validateJSON(). For a
+    // schema that arrives from outside the trust boundary (a plugin's
+    // declared config shape, a tenant's upload), where turning it into source
+    // is not an acceptable execution model. ATA_FORCE_NAPI does this for the
+    // whole process; the option does it for one validator. A misspelling
+    // must not fall through to codegen, so anything else is refused.
+    if (options.engine !== undefined && options.engine !== 'auto' && options.engine !== 'interpreter') {
+      throw new TypeError("engine must be 'auto' or 'interpreter', got " + JSON.stringify(options.engine));
+    }
+    this._interpretOnly = options.engine === 'interpreter';
     this._initialized = false;
     this._nativeReady = false;
     this._compiled = null;
@@ -1044,11 +1161,14 @@ class Validator {
     // Check cache first -- reuse compiled functions for same schema
     const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
     const mapKey = compileCacheKey(this._schemaStr, this._schemaMap);
+    var _forceNapi = this._interpretOnly || (typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI);
     // Custom formats are JS functions: bypass the compile cache since they can
-    // differ between validators that share the same schema string.
-    const cached = (this._userFormats || this._usesKeywords) ? null : _compileCache.get(mapKey);
+    // differ between validators that share the same schema string. An
+    // interpreter-only validator never touches it either way: a function a
+    // trusted validator compiled for the same schema string must not answer
+    // for it.
+    const cached = (this._userFormats || this._usesKeywords || _forceNapi) ? null : _compileCache.get(mapKey);
     let jsFn, jsCombinedFn, jsErrFn, _isCodegen = false;
-    var _forceNapi = typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI;
     // v1 removes the bookending requirement for $dynamicRef. Only the
     // interpreted engine implements that; the JS compiler and the native
     // engine both resolve the 2020-12 way, so a v1 schema using the keyword
@@ -1063,15 +1183,16 @@ class Validator {
     // either. The closure path does not call `new Function` itself, so it
     // survives the block and would quietly handle schemas it gets wrong; the
     // interpreted engine is both eval-free and more correct, so go straight
-    // there.
-    if (this._v1Dynamic || this._usesKeywords || !codegenAvailable()) {
+    // there. The forced case is decided before the probe: the probe is a
+    // `new Function` too, and a validator that promised none must not run it.
+    if (_forceNapi || this._v1Dynamic || this._usesKeywords || !codegenAvailable()) {
       jsFn = null; jsCombinedFn = null; jsErrFn = null;
     // `full` separates an entry that holds every compiled function from one
     // the verdict-only fast path seeded, where `combined` and `errFn` are null
     // because nothing has tried to build them yet. Both halves of that
     // distinction are null, and reading the second as the first costs this
     // schema its generated error function for the life of the process.
-    } else if (cached && cached.jsFn !== undefined && !_forceNapi) {
+    } else if (cached && cached.jsFn !== undefined) {
       // `full` says the error and combined functions exist too. An entry
       // without it still carries a verdict function worth reusing; the pair is
       // built by _buildDeferred below if something asks for an error, and the
@@ -1084,7 +1205,7 @@ class Validator {
       jsErrFn = cached.errFn;
       _isCodegen = !!cached.isCodegen;
       this._engine = _isCodegen ? 'codegen' : jsFn ? 'closure' : null;
-    } else if (!_forceNapi) {
+    } else {
       const uf = this._userFormats;
       const _cgFn = compileToJSCodegen(schemaObj, sm, uf);
       jsFn = _cgFn || compileToJS(schemaObj, null, sm);
@@ -1100,8 +1221,6 @@ class Validator {
       if (!uf) {
         _compileCache.set(mapKey, { jsFn, combined: undefined, errFn: undefined, isCodegen: _isCodegen, full: false });
       }
-    } else {
-      jsFn = null; jsCombinedFn = null; jsErrFn = null;
     }
     this._jsFn = jsFn;
     if (this._engine === undefined) this._engine = null;
@@ -1111,7 +1230,10 @@ class Validator {
     // shape (e.g. Fastify `params: { $ref: 'shared#' }` or property refs like
     // `{ id: { $ref: 'shared#/properties/id' } }`).
     const preprocessSchema = resolveSchemaForPreprocess(schemaObj, this._schemaMap);
-    let preprocess = buildPreprocessCodegen(preprocessSchema, options);
+    // The mutator pass (defaults, coercion, removal) is generated source too,
+    // with the schema's `default` values embedded; an interpreter-only
+    // validator takes the closure mutators instead.
+    let preprocess = this._interpretOnly ? null : buildPreprocessCodegen(preprocessSchema, options);
     if (!preprocess) {
       const applyDefaults = options.useDefaults === false ? null : buildDefaultsApplier(preprocessSchema);
       const applyCoerce = options.coerceTypes ? buildCoercer(preprocessSchema) : null;
@@ -1664,15 +1786,15 @@ class Validator {
         // abortEarly returns the shared ATA9000 stub; preserve it as-is so the
         // perf fast path stays allocation-free and the documented code stays stable.
         if (result && result.valid === false && result !== ABORT_EARLY_RESULT) {
-          // Positions come from the raw input when validateJSON set one;
-          // resolved eagerly since the cache is reset per call.
-          const positions = (enrich && self._lastRawInput != null) ? self._pos().get(self._lastRawInput) : null;
-          if (positions) self._posCache.reset();
+          // The raw input travels with the rejection when validateJSON set one.
+          // The map it implies is built on first access to `.errors`, so a
+          // caller reading only `.valid` does not pay for a document walk.
+          const rawInput = enrich ? self._lastRawInput : null;
           // One instance of a class with prototype accessors. An object
           // literal with a getter here cost a closure plus an accessor
           // definition on every rejection, several hundred nanoseconds
           // before any error was read.
-          return new RichRejection(result, data, positions, self, root, enrich);
+          return new RichRejection(result, data, rawInput, self, root, enrich);
         }
         return result;
       };
@@ -1683,74 +1805,23 @@ class Validator {
       if (this._richErrors && this.validateJSON) {
         const innerJson = this.validateJSON;
         this.validateJSON = (jsonStr) => {
+          // The inner path reads _lastRawInput to hand the raw text to the
+          // rejection it builds. Cleared as soon as it returns: the rejection
+          // carries the text itself, so nothing outlives the call.
           this._lastRawInput = jsonStr;
           let result;
           try {
             result = innerJson(jsonStr);
           } finally {
-            // Don't clear here; the enrich step below needs the cache. We
-            // clear after enrich, or in the early-return path.
+            this._lastRawInput = null;
           }
-          if (result && !result.valid && result.errors && result.errors.length) {
-            // If errors came from the inner path that already ran through the
-            // wrapped this.validate (codegen jsonValidateFn -> validate path),
-            // they may already be enriched. Detect by presence of `docUrl`:
-            // only enrich() sets it. `code` is not a safe signal because
-            // branch-collapse attaches codes to raw errors, and detecting on
-            // it left every collapsed oneOf/anyOf error unenriched on the
-            // text path.
-            const first = result.errors[0];
-            // Re-parse the input once so the enrich pass can pluck `received`
-            // and feed the suggestion engine (required-typo, format hints,
-            // coercion nudges all need the live value tree), and so the
-            // diagnostic payload carries the data on both paths below.
-            let parsedData;
-            try { parsedData = JSON.parse(jsonStr); } catch { parsedData = undefined; }
-            if (!first || !first.docUrl) {
-              const positions = (this._lastRawInput != null) ? this._pos().get(this._lastRawInput) : null;
-              // Declaration order, as validate() applies it; the text path
-              // used to enrich in emission order.
-              const ordered = result.errors.length > 1 ? sortErrorsBySchemaOrder(this._schemaObj, result.errors) : result.errors;
-              const enrichOpts = {
-                data: parsedData,
-                positions,
-                schemaPositions: this._schemaPositions,
-                schemaFile: this._source ? this._source.path : undefined,
-              };
-              const enriched = ordered.map((e) => enrich(e, enrichOpts));
-              if (enriched.length > 1) attachRelated(enriched);
-              attachDiagnosticSource(enriched, {
-                data: parsedData,
-                text: jsonStr,
-                positions,
-                schema: this._schemaObj,
-                mutatesInput: this._mutatesInput === true,
-              });
-              if (positions) this._posCache.reset();
-              this._lastRawInput = null;
-              return { valid: false, errors: enriched };
-            }
-            // Already-enriched path: still attach dataFrame if missing.
-            const positions = (this._lastRawInput != null) ? this._pos().get(this._lastRawInput) : null;
-            if (positions) {
-              for (const e of result.errors) {
-                if (e && !e.dataFrame) {
-                  const path = e.path != null ? e.path : (e.instancePath || '');
-                  const p = positions[path];
-                  if (p) e.dataFrame = { byteOffset: p.byteOffset, length: p.length, line: p.line, col: p.col, text: p.text };
-                }
-              }
-              this._posCache.reset();
-            }
-            if (result.errors.length > 1) attachRelated(result.errors);
-            attachDiagnosticSource(result.errors, {
-              data: parsedData,
-              text: jsonStr,
-              schema: this._schemaObj,
-              mutatesInput: this._mutatesInput === true,
-            });
+          // Every diagnostic the text path adds is deferred. Deciding here
+          // whether there is anything to add would mean reading `result.errors`,
+          // and on the codegen path that realizes the inner lazy layer, which is
+          // the document walk this exists to avoid.
+          if (result && result.valid === false) {
+            return new LazyJsonRejection(result, jsonStr, this, enrich);
           }
-          this._lastRawInput = null;
           return result;
         };
       }
@@ -1999,7 +2070,7 @@ class Validator {
       return;
     }
     this._ensureVocabularies();
-    if (typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI) return;
+    if (this._interpretOnly || (typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI)) return;
     if (!this._schemaStr) this._schemaStr = JSON.stringify(this._schemaObj);
     const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
     const mapKey = compileCacheKey(this._schemaStr, this._schemaMap);

package/lib/aot-impl.js

@@ -16,6 +16,7 @@
 const { compileToJSCodegenWithErrors, compileToJSCodegen, unevalContributions } = require('./js-compiler');
 const { buildDataPositionMap } = require('./data-positions');
 const { schemaHash } = require('./schema-hash');
+const ATA_VERSION = require('./version');
 const SAFE_REGEX_SOURCE = require('./safe-regex-source');
 
 // Embedded verbatim in standalone modules so the output file has no runtime
@@ -119,7 +120,7 @@ function toStandalone(validator) {
   const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
 
   const closureSrc = closureDeclLines(jsFn).join('\n');
-  return `// Auto-generated by ata-validator — do not edit
+  return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit
 'use strict';
 ${_CP_LEN_SOURCE}
 ${safeRePrelude(jsFn, jsErrFn)}${preambleSrc}
@@ -627,10 +628,15 @@ function validateJSON(text) {
   // can compare it against schemaHash(currentSchema) and know the module is
   // stale without embedding its own fingerprint.
   const hashSrc = schemaHash(validator._rawSchema !== undefined ? validator._rawSchema : validator._schemaObj);
-  const hashDecl = `const schemaHash = ${JSON.stringify(hashSrc)};\n`;
+  // The schema hash answers "is this module built from a different schema" and
+  // nothing else. Upgrading ata and not re-running the generate step leaves the
+  // hash matching, so the stale module reads as current. The module cannot ask
+  // the installed ata itself, since it imports nothing, so it carries the
+  // version that wrote it and a build compares that too.
+  const hashDecl = `const schemaHash = ${JSON.stringify(hashSrc)};\nconst ataVersion = ${JSON.stringify(ATA_VERSION)};\n`;
 
   let names = fmt.exportsSetFormats ? baseNames + ', setFormats' : baseNames;
-  names += ', schemaHash';
+  names += ', schemaHash, ataVersion';
   if (positionsCore) names += ', validateJSON';
   const parseAlias = cloneExpr ? ', _ataParse as parse' : '';
   const parseProp = cloneExpr ? ', parse: _ataParse' : '';
@@ -644,8 +650,9 @@ function validateJSON(text) {
   if (opts && opts.parse && !cloneExpr) {
     degradedNote += '// NOTE: parse() was requested but could not be generated for this schema;\n// the module has no parse export. Validate and strip with the runtime Validator.\n';
   }
-  return `// Auto-generated by ata-validator — do not edit.
+  return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit.
 // Schema is embedded; runtime has zero dependency on ata-validator.
+// Re-run the build after upgrading ata: the version above is what wrote this.
 ${degradedNote}'use strict';
 ${_CP_LEN_SOURCE}
 ${safeRePrelude(jsFn, jsErrFn)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
@@ -786,10 +793,10 @@ function bundleStandalone(Validator, schemas, opts) {
     : '';
   if (format === 'esm') {
     const extra = bundleInjects ? 'export { validators, setFormats };' : 'export { validators };';
-    return `// Auto-generated by ata-validator — do not edit\n${safeEmbed}${registry}const R=${R};\nconst validators=${arr};\nexport default validators;\n${extra}\n`;
+    return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit\n${safeEmbed}${registry}const R=${R};\nconst validators=${arr};\nexport default validators;\n${extra}\n`;
   }
   const attach = bundleInjects ? 'module.exports.setFormats=setFormats;\n' : '';
-  return `'use strict';\n${safeEmbed}${registry}var R=${R};\nmodule.exports=[${fns.join(',')}];\n${attach}`;
+  return `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit\n'use strict';\n${safeEmbed}${registry}var R=${R};\nmodule.exports=[${fns.join(',')}];\n${attach}`;
 }
 
 // Compact bundle: deduplicated code. Shared template functions + per-schema params.
@@ -898,8 +905,8 @@ function bundleCompact(Validator, schemas, opts) {
   // Generate compact bundle
   const isEsm = format === 'esm';
   let out = isEsm
-    ? '// Auto-generated by ata-validator — do not edit\n'
-    : "'use strict';\n";
+    ? `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit\n`
+    : `// Auto-generated by ata-validator ${ATA_VERSION}, do not edit\n'use strict';\n`;
   if (bundleUsesSafeRe) out += getSafeRegexEmbed() + '\n';
   if (sharedDecls.length) out += sharedDecls.join('\n') + '\n';
   const declKW = isEsm ? 'const' : 'var';