@scriptc/compiler 0.0.11 → 0.0.13

package/dist/frontend/lowering/lowerer.js

@@ -27,9 +27,9 @@ import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape
 import { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
 import { lowerEmitOverrideSpec } from "./lower-emitter.js";
-import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
+import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerCryptoModuleCall, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
 import { isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
-import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty } from "./lower-server.js";
+import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty } from "./lower-test.js";
 import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js";
@@ -282,7 +282,7 @@ export function neverTaintedJsType(L, node, t) {
     };
     return walk(t, 4);
 }
-/** The DOM undefined value — what an uninitialized checked-dynamic
+/** The dyn undefined value — what an uninitialized checked-dynamic
  * binding holds (JS: declared bindings read `undefined` before any
  * assignment). A NULL dyn slot is a trap, never a value, so every dyn
  * binding that is READABLE before its first assignment must start here:
@@ -349,10 +349,10 @@ export function ladderFenceExpr(L, surface, node, hint) {
  * only unmappable pieces are `any` (`(value: any) => value is string` —
  * the arrow the binding holds lowers those params to dyn, so the binding
  * keeps its func-ness with the same per-piece fallback). The honest
- * static subset of `any` is a binding whose VALUES are DOM-representable:
+ * static subset of `any` is a binding whose VALUES are dyn-representable:
  * the binding is 'unknown' storage with the boundary conversions
  * coerceToExpected already applies (dynFrom into the slot, validated
- * dynCheck out) and per-site SC2011 fences for the operations the DOM
+ * dynCheck out) and per-site SC2011 fences for the operations the checked-dynamic tree
  * cannot carry JS-exactly (the island still lifts those). Every OTHER
  * unmappable TS type keeps its own diagnostic — annotations exist there,
  * and the fence names the real blocker. `--dynamic` builds never reach
@@ -376,8 +376,8 @@ export function dynFallbackType(L, node, t) {
             ((elem.flags & ts.TypeFlags.Never) !== 0 || neverTaintedJsType(L, node, elem));
         const mappedElem = elem !== undefined && !elemTainted ? L.mapTypeOf(elem) : null;
         // A mappable element keeps the static array; an unmappable one makes
-        // the WHOLE value dyn (the DOM has real arrays — length/index/push
-        // read through the keyed-DOM paths; dyn-element STATIC arrays have no
+        // the WHOLE value dyn (the checked-dynamic tree has real arrays — length/index/push
+        // read through the keyed-dyn paths; dyn-element STATIC arrays have no
         // backend representation).
         if (mappedElem)
             return { kind: "array", elem: mappedElem };
@@ -2199,6 +2199,31 @@ export class Lowerer {
     mapTypeOf(t) {
         return mapType(t, this.typeCtx);
     }
+    /** The one position where a contextual UNION must not be adopted over the
+     * expression's own: the LEFT operand of `&&`, `||`, or `??`. Adopting a
+     * contextual union is normally safe because tsc proved the value
+     * assignable to the slot; that proof does not exist here, because tsc
+     * builds a logical operator's result by DROPPING the left's falsy (or
+     * nullish) arms. `const s: string | null = (c ? env : undefined) || null`
+     * contextually types the ternary `string | null` while its value is
+     * `string | undefined` — adopting that strands the very arm the operator
+     * exists to answer, throwing where Node yields the default. Such operands
+     * represent by their own union; the operator's own lowering re-tags on
+     * the branch where the dropped arms are gone. Narrow by design: only the
+     * union choice is unsound here. A contextual ARRAY still types the
+     * element, and an unmappable own type still falls back to the context. */
+    inLogicalLeftPosition(node) {
+        let n = node;
+        while (n.parent && ts.isParenthesizedExpression(n.parent))
+            n = n.parent;
+        const p = n.parent;
+        if (!p || !ts.isBinaryExpression(p) || p.left !== n)
+            return false;
+        const k = p.operatorToken.kind;
+        return (k === ts.SyntaxKind.AmpersandAmpersandToken ||
+            k === ts.SyntaxKind.BarBarToken ||
+            k === ts.SyntaxKind.QuestionQuestionToken);
+    }
     /** True when a ?. token blocks this lowering — i.e. it is NOT the one an
      * active optional-chain lowering is currently handling. Every receiver-
      * typed lowering that supports chained receivers guards with this
@@ -2317,7 +2342,7 @@ export class Lowerer {
         // The reverse — a TYPED value flowing into an 'unknown' slot
         // (`const u: unknown = 5`, an unknown-typed param/return) — IS tsc-clean
         // and rejected here: a typed value has no dynamic representation
-        // (constructing a DOM from static values is deliberately out this
+        // (constructing a dyn from static values is deliberately out this
         // round; only JSON.parse results are dyn).
         if (actual.kind === "dyn") {
             this.unsupported("SC1100", node, `passing 'unknown' values where '${this.fmt(expected)}' is expected`);
@@ -2426,8 +2451,8 @@ export class Lowerer {
             }
             // A CHECKED-DYNAMIC (dyn/'unknown') value entering the island (the
             // `isJson ? JSON.parse(text) : islandParser(text)` config ternary):
-            // the DOM tree deep-copies into engine values — data kinds only; a
-            // DOM carrying a boxed function/handle/promise throws the catchable
+            // the dyn tree deep-copies into engine values — data kinds only; a
+            // dyn carrying a boxed function/handle/promise throws the catchable
             // TypeError at runtime (trust-but-verify, like every boundary).
             if (expr.type.kind === "dyn") {
                 return { kind: "jsMarshal", value: expr, type: JSVAL, loc: expr.loc };
@@ -2460,21 +2485,35 @@ export class Lowerer {
             return expr;
         }
         if (expr.type.kind === "jsval" && expected.kind !== "jsval") {
-            // The jsval→DOM crossing (the world unification's engine-handle
+            // The jsval→dyn crossing (the world unification's engine-handle
             // kind): an 'any'-typed engine value flowing into an 'unknown'/
-            // 'object'/JS-residue slot wraps BY REFERENCE as the DOM's island
-            // kind — engine scalars normalize to native DOM kinds at wrap time,
-            // typeof/truthiness/String()/=== route to the engine, un-armed DOM
+            // 'object'/JS-residue slot wraps BY REFERENCE as the checked-dynamic tree's island
+            // kind — engine scalars normalize to native dyn kinds at wrap time,
+            // typeof/truthiness/String()/=== route to the engine, un-armed dyn
             // walks fence loudly, and the value unwraps back identity-preserved
             // (scr_jsval_from_dyn). Monotone under evolution/widening: a value
             // wraps once at its first dyn edge and stays valid through every
             // subsequent dyn slot; narrowing never changes representation.
             // This wrap RETIRES the silent-wrong-answer fence-closure box for
-            // jsval members of DOM object literals (lowerDynObjectLiteral's
+            // jsval members of dyn object literals (lowerDynObjectLiteral's
             // coercion lands here first).
             if (expected.kind === "dyn") {
                 return { kind: "dynFromJsval", value: expr, type: DYN, loc: expr.loc };
             }
+            // An island value flowing into a PROMISE-typed slot (the inferred
+            // `loadPlugins` return — `Promise.all(...)` lowered engine-side
+            // against a Promise<any[]> inference): the island→static promise
+            // bridge — the engine promise settles a fresh static promise (void
+            // fulfillments drop, `any[]`-declared fulfillments exit
+            // Array.isArray-gated by reference at the settle, 'any' parks as an
+            // island handle). Only inner shapes the bridge can deliver take the
+            // arm; the rest keep the exit fence with the type named.
+            if (expected.kind === "promise" &&
+                (expected.inner.kind === "void" ||
+                    expected.inner.kind === "jsval" ||
+                    (expected.inner.kind === "array" && expected.inner.elem.kind === "jsval"))) {
+                return { kind: "jsBridgePromise", value: expr, type: expected, loc: expr.loc };
+            }
             // The exit set: everything round-trippable, plus bare undefined-armed
             // unions of JSON-safe data arms (the engine's undefined takes the
             // undefined arm before the JSON detour) — canExitIslandToType.
@@ -2485,10 +2524,10 @@ export class Lowerer {
         }
         // A TYPED value flowing into an 'unknown' slot (`const u: unknown = 5`,
         // an unknown-typed param/return, a dyn-valued index slot): the
-        // static→DOM conversion — dynFrom, a DEEP COPY (the jsMarshal aliasing
+        // static→dyn conversion — dynFrom, a DEEP COPY (the jsMarshal aliasing
         // stance intoIndexValueSlot documents; SEMANTICS.md). Bare
-        // undefined/null literals store the DOM unit values. Types outside the
-        // DOM's domain (bytes, classes, Maps, ...) fall through to
+        // undefined/null literals store the dyn unit values. Types outside the
+        // dyn's domain (bytes, classes, Maps, ...) fall through to
         // requireExactShape's SC1101 fence.
         // A promise flowing into a VOID-promise slot (an inferred
         // Promise<never> return holding a `return Promise.reject(value)` the
@@ -2576,7 +2615,7 @@ export class Lowerer {
         // JS func-into-func mismatches ride the checked-dynamic function
         // boundary: box the value (dynFrom), adapt to the slot (dynCheck) —
         // the thunk delivers JS arity exactly (extras ignored, missing args
-        // the undefined DOM value), so `return _return` fits _mustCallInner's
+        // the undefined dyn value), so `return _return` fits _mustCallInner's
         // inferred (unknown) => unknown slot even though the wrapper declares
         // (). JS files only: TypeScript signatures keep the exact-shape
         // fences (a mismatch there is a compile-time story, not a boundary).
@@ -2884,7 +2923,7 @@ export class Lowerer {
      *   arr       — array into array whose element pair lifts (per-element
      *               copy loop, arrayWidthHelper)
      *   dynIn     — a typed value into an 'unknown' (dyn) slot — the same
-     *               static→DOM deep copy coerceToExpected applies top-level
+     *               static→dyn deep copy coerceToExpected applies top-level
      *   upcast    — a derived class instance into a base-typed slot (the
      *               prefix-layout pointer reinterpret, no copy)
      *   funcAdapt — a function into a slot whose signature differs only by
@@ -2894,7 +2933,7 @@ export class Lowerer {
     widthLiftPlan(src, dst) {
         if (typeEquals(src, dst))
             return { how: "copy" };
-        // An 'unknown' (dyn) DESTINATION slot: the static→DOM conversion —
+        // An 'unknown' (dyn) DESTINATION slot: the static→dyn conversion —
         // dynFrom, a DEEP COPY (`{ v: 5 }` into `{ v: unknown }`, `number[]`
         // into `unknown[]` — tsc's top type over the width family's copies).
         if (dst.kind === "dyn" && src.kind !== "dyn" && this.dynConvertible(src)) {
@@ -3156,7 +3195,7 @@ export class Lowerer {
                     // A target field MISSING on the source: legal exactly when it is
                     // optional-flavored (an undefined-armed union) — the unset field
                     // IS the undefined arm, the same rule literal completion applies
-                    // — or 'unknown' (a dyn slot holds the DOM undefined, exactly
+                    // — or 'unknown' (a dyn slot holds the dyn undefined, exactly
                     // the absent-property read: the options-record call shape
                     // against `{ plugins: unknown, ... }`). Never for tuples: a
                     // completed position would change .length and JSON where Node
@@ -3312,7 +3351,7 @@ export class Lowerer {
                         fields: to.fields.map((f) => {
                             const lift = plan.get(f.name);
                             if ("absentDyn" in lift) {
-                                // The unset 'unknown' field: the DOM undefined — exactly
+                                // The unset 'unknown' field: the dyn undefined — exactly
                                 // the absent-property read's answer.
                                 return { name: f.name, value: dynUndefinedExpr(loc) };
                             }
@@ -3897,7 +3936,7 @@ export class Lowerer {
         if (typeEquals(src, dst))
             return true;
         // The island boundary joins the mechanical set: values that MARSHAL
-        // in (units, the checked-dynamic DOM copy, JSON-safe data, liftable
+        // in (units, the checked-dynamic deep copy, JSON-safe data, liftable
         // composites, marshalable closures — coerceToExpected's jsval-IN
         // block) and island handles whose exits VALIDATE (boundaryExitSafe) —
         // the `defaultFallback(cfg) { return { login, id, scopes } }` shape,
@@ -3982,7 +4021,7 @@ export class Lowerer {
         //   never-called mismatched callback is exact; divergence 38's stance
         //   extended to calls).
         // - voidRet "dyn"/"jsval": calling yields JS's undefined — the exact
-        //   undefined DOM/engine value after the call's effects.
+        //   undefined dyn/engine value after the call's effects.
         // - voidRet "strand": a void result where the slot promises a typed
         //   value — the call runs (a `never` thrower never comes back, so the
         //   trap is unreachable there), then the stranded TypeError.
@@ -4767,7 +4806,7 @@ export class Lowerer {
             return { kind: "call", callee: helper, args: [e], type: JSVAL, loc };
         }
         // Checked-dynamic values and marshalable closures ride jsMarshal
-        // directly (the DOM deep copy / the host-function wrap).
+        // directly (the checked-dynamic tree deep copy / the host-function wrap).
         if (e.type.kind === "dyn" || e.type.kind === "func") {
             return { kind: "jsMarshal", value: e, type: JSVAL, loc };
         }
@@ -5208,9 +5247,9 @@ export class Lowerer {
         }
         // An OBJECT LITERAL against a checked-dynamic slot in a JS file (the
         // getSupportInfo options argument — a dyn-ABI param): the value's
-        // world IS the DOM — build the DOM literal directly, before the
+        // world IS the checked-dynamic tree — build the dyn literal directly, before the
         // island gate could claim the checker's `any` context (an island
-        // build could never land in the slot: no engine→DOM crossing).
+        // build could never land in the slot: no engine→dyn crossing).
         if (expected?.kind === "dyn") {
             let x = node;
             while (ts.isParenthesizedExpression(x))
@@ -5260,7 +5299,7 @@ export class Lowerer {
     }
     /** A value flowing into an index-signature VALUE slot (an overflow
      * literal entry, a dynamic-keyed record write). dyn slots (`unknown`
-     * signatures — ModelPricing's) take a DOM conversion: dyn values pass
+     * signatures — ModelPricing's) take a dyn conversion: dyn values pass
      * through, JSON-safe static values convert with dynFrom (a deep copy —
      * the jsMarshal aliasing stance), everything else keeps the dyn-boundary
      * fence. Typed slots ride the ordinary coercion path (union slots wrap
@@ -5270,12 +5309,12 @@ export class Lowerer {
             return this.coerceInto(node, value, indexValue);
         if (value.type.kind === "dyn")
             return value;
-        // Bare `undefined`/`null` literals store the DOM unit values (JS keeps
+        // Bare `undefined`/`null` literals store the dyn unit values (JS keeps
         // the key; JSON.stringify drops an undefined-valued one, like Node).
         if (value.kind === "unitLit") {
             return { kind: "dynFrom", value, type: DYN, loc: value.loc };
         }
-        // An ISLAND ('any') value: the by-reference jsval→DOM wrap — the same
+        // An ISLAND ('any') value: the by-reference jsval→dyn wrap — the same
         // edge coerceToExpected converts (dyn slots accept engine values).
         if (value.type.kind === "jsval") {
             return { kind: "dynFromJsval", value, type: DYN, loc: value.loc };
@@ -5291,13 +5330,13 @@ export class Lowerer {
     withUndefinedArmOf(t) {
         return withUndefinedArmCanonical(t, this.unions);
     }
-    /** True when a static type converts to a dyn DOM value (the dynFrom
-     * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the DOM's
+    /** True when a static type converts to a dyn value (the dynFrom
+     * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the checked-dynamic tree's
      * bytes kind, payload copied; stdin chunks into unknown-typed helpers),
      * an undefined-armed union whose other arms are JSON-safe — the
-     * undefined arm becomes the undefined DOM singleton — or a BOXABLE
+     * undefined arm becomes the undefined dyn singleton — or a BOXABLE
      * function type (the checked-dynamic function boundary: the closure
-     * crosses as the DOM's callable kind, identity preserved). */
+     * crosses as the checked-dynamic tree's callable kind, identity preserved). */
     dynConvertible(t) {
         return canConvertToDyn(t, (id) => this.shapes.get(id), (id) => this.unions.get(id));
     }
@@ -5800,7 +5839,7 @@ export class Lowerer {
                     if (abi.kind === "dyn" || abi.kind === "jsval") {
                         // A DYNAMIC-TIER pattern source (`function f({} = a)` with
                         // `a: any` — jsval for island values, dyn for the checked-
-                        // dynamic DOM): the slot holds its tier's undefined directly,
+                        // dynamic dyn): the slot holds its tier's undefined directly,
                         // so the default test is the runtime undefined test — then
                         // the pattern destructures the picked value.
                         const dflt = this.lowerExprExpecting(decl.initializer, abi);
@@ -5868,7 +5907,7 @@ export class Lowerer {
                 if (abi.kind === "dyn" || abi.kind === "jsval") {
                     // A DYNAMIC-TIER defaulted param (`function f(x = a)` with
                     // `a: any` — jsval for island values, dyn for the checked-
-                    // dynamic DOM): the slot holds its tier's undefined directly —
+                    // dynamic dyn): the slot holds its tier's undefined directly —
                     // the body local picks the default on the runtime test.
                     const loc = locOf(decl);
                     const slot = this.declareHiddenLocal(name, abi);
@@ -6053,7 +6092,7 @@ export class Lowerer {
                 continue;
             // dyn captures ride an UNTRACED obj-box (scr_dyn_retain_v/release_v
             // — boxNewC): the mustCall wrapper closing over its implicit-any
-            // `fn` param. A DOM tree is pure data except the function kind,
+            // `fn` param. A dyn tree is pure data except the function kind,
             // whose closure edge the collector never sees — cycles through a
             // captured dyn are uncollectable (leak, never dangle: trial
             // deletion treats untraced edges as external roots). SEMANTICS.md.
@@ -6388,7 +6427,7 @@ export class Lowerer {
                 // The CHECKED-DYNAMIC twin of the handle rescue (the runtime-world
                 // local rule): an unmappable declared type over a dyn initializer
                 // (`const first = plugins[0]` — the checker spells 'string |
-                // object' while the read is a DOM keyed read) keeps the binding
+                // object' while the read is a dyn keyed read) keeps the binding
                 // dyn; typed use sites ride validated extractions and the routed
                 // engine ops, exactly the JSON.parse-binding story.
                 if (mapped === null && init.type.kind === "dyn") {
@@ -6929,6 +6968,11 @@ export class Lowerer {
         const fsLadder = this.lowerFsLadderCall(call, bi, locOf(access));
         if (fsLadder)
             return fsLadder;
+        // The crypto introspection statics (getFips and the name lists) bake
+        // at the call site — no runtime entry exists to table.
+        const cryptoServed = this.lowerCryptoModuleCall(call, bi, locOf(access));
+        if (cryptoServed)
+            return cryptoServed;
         const builtinFn = builtinModuleFnOf(this, bi.module, bi.member);
         if (!builtinFn) {
             this.noLowering(`${bi.module}.${bi.member}`, call, builtinFenceHintOf(bi.module, bi.member), this.checker.getSymbolAtLocation(access.name));
@@ -6972,6 +7016,13 @@ export class Lowerer {
         if (bi.module === "module" && bi.member === "builtinModules") {
             return builtinModulesArrayLit(loc);
         }
+        // tls.rootCertificates through the namespace: the same runtime-valued
+        // constant the named-import read lowers to.
+        {
+            const roots = lowerTlsRootCertificates(this, bi, loc);
+            if (roots)
+                return roots;
+        }
         if (bi.member === "constants" && bi.module === "fs") {
             // A bare `fs.constants` read (not one of the baked bits above).
             this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
@@ -7114,14 +7165,17 @@ export class Lowerer {
     lowerFsConstantsProperty(expr) {
         return lowerFsConstantsProperty(this, expr);
     }
-    lowerHttp2ConstantsProperty(expr) {
-        return lowerHttp2ConstantsProperty(this, expr);
+    lowerBuiltinConstantsProperty(expr) {
+        return lowerBuiltinConstantsProperty(this, expr);
+    }
+    builtinConstantBindingOf(ident) {
+        return builtinConstantBindingOf(this, ident);
     }
-    http2ConstantBindingOf(ident) {
-        return http2ConstantBindingOf(this, ident);
+    builtinConstantsDestructureDecl(nameNode, init) {
+        return builtinConstantsDestructureDecl(this, nameNode, init);
     }
-    http2ConstantsDestructureDecl(nameNode, init) {
-        return http2ConstantsDestructureDecl(this, nameNode, init);
+    lowerCryptoModuleCall(expr, bi, loc) {
+        return lowerCryptoModuleCall(this, expr, bi, loc);
     }
     lowerProcessStreamProperty(expr) {
         return lowerProcessStreamProperty(this, expr);