@scriptc/compiler 0.4.3 → 0.4.5

package/dist/frontend/lowering/containers/bytes.js

@@ -1,17 +1,20 @@
 import { keyedHelperName } from "../stable-names.js";
-import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js";
+import { allBytesArms, indexedUnionArms, lowerIndexedUnionMethod } from "../indexed-unions.js";
+import { boolLit, dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../../ir/build.js";
 import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js";
 import * as ts from "../../ts7/adapter.js";
+import { constituentTypes } from "../../ts7/checker.js";
 import { BIGINT_T, BOOL, BYTES_ELEMENT_NAME, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isUnitType, typeEquals, } from "../../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import { stdlibGlobalNameOf } from "../surfaces.js";
-import { newFnCtx, own } from "../lowerer.js";
+import { ENTRY_NAME, newFnCtx, own } from "../lowerer.js";
+import { everyStmt } from "../../../ir/traverse.js";
 import { buildBytesSortFn, closureKeyOrder } from "../lower-array-sort.js";
 import { isSafeToDiscard } from "../expressions/evaluation-safety.js";
 import { lowerDynObjectLiteral } from "../expressions/object-literals.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, } from "../optional-arguments.js";
 import { lowerArraySpreadItems, lowerCheckedArrayFrom } from "./array-construction.js";
-import { lowerToNumberArgument } from "../lower-exprs.js";
+import { lowerOptionalNumber, lowerToNumberArgument } from "../lower-exprs.js";
 import { lowerBytesIteratorValue } from "../iterator-adapters.js";
 import { lowerArrayCallback } from "./callback-arguments.js";
 import { callbackSite, findPredicateOk, predicateToBoolean } from "./array-callbacks.js";
@@ -726,6 +729,109 @@ function lowerDataViewNew(lowerer, expr) {
         lowerer.noLowering("DataView constructor argument count", expr);
     return lowerArrayBufferView(lowerer, args, "dv", locOf(expr));
 }
+/** `receiver.set(src, offset?)` on a lowered typed-array receiver. */
+function bytesSetIntrinsic(lowerer, receiver, argNodes, loc) {
+    const src = lowerer.lowerExpr(argNodes[0]);
+    const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
+    const args = [src.type.kind === "bytes" ? src : lowerer.coerceInto(argNodes[0], src, DYN)];
+    if (argNodes.length === 2)
+        args.push(lowerOptionalArgument(lowerer, argNodes[1], F64, {
+            kind: "numLit",
+            value: 0,
+            type: F64,
+            loc,
+        }));
+    return { kind: "bytesIntrinsic", method, receiver, args, type: VOID, loc };
+}
+/** `Uint8Array.prototype.set.call(target, src, offset?)`, through any typed
+ * array constructor's prototype (they share %TypedArray%.prototype.set). A
+ * target the checker types as a typed array or Buffer lowers like
+ * `target.set(src, offset)`. Any other target, a DataView included, is
+ * checked at run time: a typed array calls its `set`, and
+ * anything else throws Node's TypeError "this is not a typed array.",
+ * after every argument is evaluated. */
+export function lowerBytesPrototypeSetCall(lowerer, call, access) {
+    if (call.questionDotToken ||
+        access.questionDotToken ||
+        access.name.text !== "call" ||
+        !ts.isPropertyAccessExpression(access.expression))
+        return null;
+    const method = access.expression;
+    const proto = method.expression;
+    if (method.questionDotToken ||
+        method.name.text !== "set" ||
+        !ts.isPropertyAccessExpression(proto) ||
+        proto.questionDotToken ||
+        proto.name.text !== "prototype" ||
+        !ts.isIdentifier(proto.expression) ||
+        !lowerer.isStdlibMember(method))
+        return null;
+    const ctor = lowerer.resolveValueSymbol(proto.expression);
+    if (!ctor || !lowerer.isStdlibSymbol(ctor) || !own(BYTES_CTORS, ts.symbolName(ctor)))
+        return null;
+    const argNodes = call.arguments.nodes;
+    if (argNodes.length < 2 || argNodes.length > 3 || argNodes.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(call);
+    const target = lowerer.lowerExpr(argNodes[0]);
+    // A DataView lowers to the same bytes type, so the checker type decides:
+    // only a typed array (or a Buffer) takes the method's path.
+    const targetSymbol = lowerer.typeOf(argNodes[0]).getSymbol();
+    if (target.type.kind === "bytes" &&
+        targetSymbol !== undefined &&
+        lowerer.isStdlibSymbol(targetSymbol) &&
+        (own(BYTES_CTORS, ts.symbolName(targetSymbol)) !== undefined ||
+            ts.symbolName(targetSymbol) === "Buffer"))
+        return bytesSetIntrinsic(lowerer, target, argNodes.slice(1), loc);
+    const slot = (value) => {
+        const local = lowerer.declareHiddenLocal("%setArg", DYN);
+        return {
+            decl: { kind: "varDecl", localId: local.id, init: value, loc },
+            read: varRef(local.id, DYN, loc),
+        };
+    };
+    const slots = [
+        slot(lowerer.coerceInto(argNodes[0], target, DYN)),
+        ...argNodes.slice(1).map((arg) => slot(lowerer.lowerExprExpecting(arg, DYN))),
+    ];
+    const isTypedArray = {
+        kind: "libCall",
+        fn: "util.typeIs",
+        args: [slots[0].read, { kind: "strLit", value: "isTypedArray", type: STRING, loc }],
+        type: BOOL,
+        loc,
+    };
+    return {
+        kind: "seqExpr",
+        stmts: [
+            ...slots.map((s) => s.decl),
+            {
+                kind: "if",
+                cond: { kind: "unary", op: "!", operand: isTypedArray, type: BOOL, loc },
+                then: [
+                    {
+                        kind: "exprStmt",
+                        expr: nodeThrowExpr(1, "", "this is not a typed array.", VOID, loc),
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            },
+        ],
+        result: {
+            kind: "dynInvoke",
+            recv: slots[0].read,
+            method: "set",
+            calleeName: ts.getTextOfNode(method),
+            args: slots.slice(1).map((s) => s.read),
+            type: DYN,
+            loc,
+        },
+        type: DYN,
+        loc,
+    };
+}
 /** Method calls on typed-array/Buffer receivers: slice (copy), subarray
  * (shared view), toReversed, copyWithin, set(src,
  * offset?), and the u8-only Buffer surface: toString(enc?) plus the
@@ -733,11 +839,131 @@ function lowerDataViewNew(lowerer, expr) {
  * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
  * else the lib declares (fill, indexOf, reverse, ...) falls through to
  * the SC2020 member fence. Null when this isn't a bytes method call. */
+/** The [needle, fromIndex] arguments of TypedArray indexOf, lastIndexOf
+ * and includes. A present fromIndex converts even when it is undefined
+ * (NaN, which ToIntegerOrInfinity makes 0); an absent one is 0, or
+ * +Infinity for lastIndexOf, which starts at the last element. */
+function elementSearchArgs(lowerer, call, name) {
+    const nodes = call.arguments.nodes;
+    const loc = locOf(call);
+    const needle = lowerer.lowerExprExpecting(nodes[0], F64);
+    const from = nodes[1]
+        ? lowerOptionalNumber(lowerer, lowerer.lowerExpr(nodes[1]), locOf(nodes[1]), nodes[1])
+        : {
+            kind: "numLit",
+            value: name === "lastIndexOf" ? Infinity : 0,
+            type: F64,
+            loc,
+        };
+    // An undefined fromIndex is NaN once converted, which starts at 0.
+    if (from.kind === "unitLit")
+        return [needle, { kind: "numLit", value: NaN, type: F64, loc }];
+    if (from.type.kind === "undefinedT" || from.type.kind === "void")
+        return [
+            needle,
+            {
+                kind: "seqExpr",
+                stmts: [{ kind: "exprStmt", expr: from, loc }],
+                result: { kind: "numLit", value: NaN, type: F64, loc },
+                type: F64,
+                loc,
+            },
+        ];
+    if (from.type.kind !== "f64")
+        lowerer.noLowering(`.${name} with a non-number fromIndex`, call);
+    return [needle, from];
+}
+const ELEMENT_SEARCHES = {
+    indexOf: "indexOfElem",
+    lastIndexOf: "lastIndexOfElem",
+    includes: "includesElem",
+};
+/** Whether a union has a Buffer arm, under any alias name: each arm's own
+ * symbol names it. */
+function hasBufferArm(type) {
+    const arms = type.flags & ts.TypeFlags.Union ? constituentTypes(type) : [type];
+    return arms.some((arm) => {
+        const symbol = arm.getSymbol();
+        return symbol !== undefined && ts.symbolName(symbol) === "Buffer";
+    });
+}
+/** The element-kind-generic typed-array methods on a union of typed
+ * arrays (indexed-unions.ts): the arguments lower as for one typed array,
+ * and each arm runs the method on its own receiver. Null for the methods
+ * that need a narrowing to one kind first. */
+function lowerUnionBytesMethodCall(lowerer, call, access, name) {
+    if (isJsSourceFile(ts.getSourceFileOfNode(call)))
+        return null;
+    // A Buffer arm's methods differ from a typed array's (slice aliases, fill
+    // checks its range, searches take strings and wrap numbers), so such a
+    // union narrows to its arms first.
+    if (hasBufferArm(lowerer.typeOf(access.expression)))
+        return null;
+    const nodes = call.arguments.nodes;
+    if (nodes.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(call);
+    const num = (value) => ({ kind: "numLit", value, type: F64, loc });
+    const optional = (i, fallback, type = F64) => nodes[i] ? lowerOptionalArgument(lowerer, nodes[i], type, fallback) : fallback;
+    let method;
+    let args;
+    let result;
+    if ((name === "slice" || name === "subarray") && nodes.length <= 2) {
+        method = name;
+        args = () => [optional(0, num(0)), optional(1, num(Infinity))];
+        result = "receiver";
+    }
+    else if (name === "fill" && nodes.length <= 3) {
+        method = "fillElem";
+        args = () => [optional(0, num(0)), optional(1, num(0)), optional(2, num(Infinity))];
+        result = "receiver";
+    }
+    else if (name === "copyWithin" && nodes.length <= 3) {
+        method = "copyWithin";
+        args = () => [optional(0, num(0)), optional(1, num(0)), optional(2, num(Infinity))];
+        result = "receiver";
+    }
+    else if (name === "toReversed" && nodes.length === 0) {
+        method = "toReversed";
+        args = () => [];
+        result = "receiver";
+    }
+    else if (Object.hasOwn(ELEMENT_SEARCHES, name) && (nodes.length === 1 || nodes.length === 2)) {
+        method = ELEMENT_SEARCHES[name];
+        args = () => elementSearchArgs(lowerer, call, name);
+        result = name === "includes" ? BOOL : F64;
+    }
+    else if (name === "join" && nodes.length <= 1) {
+        method = "join";
+        args = () => [optional(0, { kind: "strLit", value: ",", type: STRING, loc }, STRING)];
+        result = STRING;
+    }
+    else if (name === "set" && (nodes.length === 1 || nodes.length === 2)) {
+        const source = lowerer.mapTypeOf(lowerer.typeOf(nodes[0]));
+        method = source?.kind === "bytes" ? "setFrom" : "setFromDyn";
+        args = () => {
+            const src = lowerer.lowerExpr(nodes[0]);
+            const first = src.type.kind === "bytes" ? src : lowerer.coerceInto(nodes[0], src, DYN);
+            return nodes.length === 2 ? [first, optional(1, num(0))] : [first];
+        };
+        result = VOID;
+    }
+    else
+        return null;
+    const receiver = lowerer.lowerExpr(access.expression);
+    const arms = indexedUnionArms(lowerer, receiver.type);
+    if (!arms || !allBytesArms(arms))
+        return null;
+    return lowerIndexedUnionMethod(lowerer, receiver, arms, method, args(), result, loc);
+}
 export function lowerBytesMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
     const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const unionArms = receiverIr ? indexedUnionArms(lowerer, receiverIr) : null;
+    if (unionArms && allBytesArms(unionArms) && lowerer.isStdlibMember(access))
+        return lowerUnionBytesMethodCall(lowerer, call, access, name);
     if (receiverIr?.kind !== "bytes")
         return null;
     if (!lowerer.isStdlibMember(access))
@@ -780,6 +1006,25 @@ export function lowerBytesMethodCall(lowerer, call, access) {
                 return value;
         }
     }
+    // TypedArray indexOf / lastIndexOf / includes (the Buffer-declared forms,
+    // which also take string and Buffer needles, lowered above).
+    if (Object.hasOwn(ELEMENT_SEARCHES, name) &&
+        !lowerer.checker
+            .getSymbolAtLocation(access.name)
+            ?.declarations.some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer")) {
+        if (nArgs < 1 || nArgs > 2 || call.arguments.nodes.some(ts.isSpreadElement)) {
+            lowerer.noLowering(`.${name} with ${nArgs} arguments on typed arrays`, call);
+        }
+        const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
+        return {
+            kind: "bytesIntrinsic",
+            method: ELEMENT_SEARCHES[name],
+            receiver,
+            args: elementSearchArgs(lowerer, call, name),
+            type: name === "includes" ? BOOL : F64,
+            loc,
+        };
+    }
     if (name === "toReversed") {
         if (nArgs !== 0) {
             lowerer.noLowering(`.toReversed with ${nArgs} arguments on typed arrays`, call);
@@ -906,19 +1151,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const src = lowerer.lowerExpr(call.arguments.nodes[0]);
-        const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
-        const args = [
-            src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments.nodes[0], src, DYN),
-        ];
-        if (nArgs === 2)
-            args.push(lowerOptionalArgument(lowerer, call.arguments.nodes[1], F64, {
-                kind: "numLit",
-                value: 0,
-                type: F64,
-                loc,
-            }));
-        return { kind: "bytesIntrinsic", method, receiver, args, type: VOID, loc };
+        return bytesSetIntrinsic(lowerer, receiver, call.arguments.nodes, loc);
     }
     if (name === "toString") {
         // Buffer's toString(encoding?) — utf8 by default. A 0-arg toString
@@ -1055,6 +1288,8 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (receiverIr.elem !== "u8") {
             lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
         }
+        if (!numericArguments(lowerer, call))
+            return dynNumericCall(lowerer, call, access, name, receiverIr, loc);
         const write = name.startsWith("write");
         const required = write ? 1 : 0; // value; offset defaults to 0
         if (nArgs < required || nArgs > required + 1) {
@@ -1223,6 +1458,30 @@ const BUF_BIGINT_METHODS = {
     writeBigUint64BE: { sign: false, le: false },
     writeBigUint64LE: { sign: false, le: true },
 };
+/** Whether every argument of a numeric read/write is statically a number. */
+function numericArguments(lowerer, call) {
+    return call.arguments.nodes.every((a) => lowerer.mapTypeOf(lowerer.typeOf(a))?.kind === "f64");
+}
+/** A numeric read/write with an argument that is not a number (a string
+ * offset from untyped JavaScript): the checked-dynamic Buffer method runs
+ * Node's argument validation at runtime. */
+function dynNumericCall(lowerer, call, access, name, receiverIr, loc) {
+    const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
+    return {
+        kind: "dynCheck",
+        value: {
+            kind: "dynInvoke",
+            recv: { kind: "dynFrom", value: receiver, type: DYN, loc, liveRef: true },
+            method: name,
+            calleeName: ts.getTextOfNode(access),
+            args: call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, DYN)),
+            type: DYN,
+            loc,
+        },
+        type: F64,
+        loc,
+    };
+}
 /** The variable-width quartet (offset + byteLength) → sign/endian token. */
 const BUF_NUM_VAR_METHODS = {
     readUIntBE: "ube",
@@ -1565,7 +1824,7 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
  * or empty encoding and throws ERR_UNKNOWN_ENCODING for an unknown name; an
  * ArrayBuffer takes the second argument as its byte offset; other sources
  * ignore it. */
-function dynBufferFromParts(source, encoding, loc) {
+function dynBufferFromParts(source, encoding, loc, length) {
     const utf8 = { kind: "strLit", value: "utf8", type: STRING, loc };
     const isString = (x) => ({
         kind: "dynTest",
@@ -1606,19 +1865,39 @@ function dynBufferFromParts(source, encoding, loc) {
             type: BYTES_U8,
             loc,
         },
-        // An ArrayBuffer takes the second argument as its byte offset
-        // (scr_buffer_from_dyn_offset_pooled); other values convert with utf8.
-        else_: {
-            kind: "libCall",
-            fn: "buffer.poolFromDynOffset",
-            args: [source, encoding],
-            type: BYTES_U8,
-            loc,
-        },
+        // An ArrayBuffer takes the second argument as its byte offset and the
+        // third as its length (scr_buffer_from_dyn_range_pooled); other values
+        // convert with utf8.
+        else_: length
+            ? {
+                kind: "libCall",
+                fn: "buffer.poolFromDynRange",
+                args: [source, encoding, length],
+                type: BYTES_U8,
+                loc,
+            }
+            : {
+                kind: "libCall",
+                fn: "buffer.poolFromDynOffset",
+                args: [source, encoding],
+                type: BYTES_U8,
+                loc,
+            },
         type: BYTES_U8,
         loc,
     };
 }
+/** Buffer.from(arrayBuffer, byteOffset[, length]): each argument in order
+ * as a checked-dynamic value, read by the runtime as Node's
+ * fromArrayBuffer reads them. */
+function bufferFromArrayBufferRange(lowerer, args, loc, first) {
+    const operands = [0, 1, 2].map((i) => i === 0 && first
+        ? first
+        : args[i]
+            ? lowerer.lowerExprExpecting(args[i], DYN)
+            : dynUndefinedExpr(loc));
+    return { kind: "libCall", fn: "buffer.poolFromDynRange", args: operands, type: BYTES_U8, loc };
+}
 /** Lowers `source` and `encNode` (or undefined) into hidden dyn locals, in
  * source order, and builds the result from their references. */
 function withDynBufferArguments(lowerer, source, encNode, loc, build) {
@@ -1651,30 +1930,37 @@ function dynBufferFromRuntimeEncoding(lowerer, value, encNode, loc) {
         return null;
     return withDynBufferArguments(lowerer, value, encNode, loc, (source, encoding) => dynBufferFromParts(source, encoding, loc));
 }
-/** The deprecated `new Buffer(arg[, encoding])` in a dependency's
- * JavaScript, through the global or an alias of it (buffer-crc32 and yazl
- * keep it as the fallback for runtimes without Buffer.alloc/Buffer.from).
- * Node never emits DEP0005 for calls from node_modules, so the construction
- * is exactly Node's: a number allocates zero-filled bytes (and throws
- * ERR_INVALID_ARG_TYPE beside a string second argument), anything else
- * converts as Buffer.from does. Null elsewhere: other callers owe the
- * deprecation warning. */
-export function lowerNodeModulesBufferConstruct(lowerer, expr) {
-    const sf = expr.getSourceFile();
-    if (!isJsSourceFile(sf) || !/[\\/]node_modules[\\/]/.test(sf.fileName))
+/** The deprecated `Buffer(arg[, encodingOrOffset[, length]])`, called or
+ * constructed through the global or an alias of it, as Node's Buffer
+ * function runs it: the arguments evaluate in order, DEP0005 is reported
+ * on the next tick (once, and never for a call made from node_modules,
+ * which only counts toward Node's 10000-call check), then a number
+ * allocates zero-filled bytes (and throws ERR_INVALID_ARG_TYPE beside a
+ * string second argument) and anything else converts as Buffer.from does.
+ * Null for spread arguments and more than three. */
+export function lowerBufferConstruct(lowerer, expr) {
+    if (ts.isCallExpression(expr) && expr.questionDotToken)
         return null;
     const args = expr.arguments?.nodes ?? [];
-    if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement))
+    if (args.length > 3 || args.some(ts.isSpreadElement))
         return null;
     if (stdlibGlobalNameOf(lowerer, expr.expression) !== "Buffer")
         return null;
     const loc = locOf(expr);
-    const value = withDynBufferArguments(lowerer, lowerer.lowerExpr(args[0]), args[1], loc, (source, encoding) => ({
+    const locals = [0, 1, 2].slice(0, Math.max(args.length, 2)).map((i) => {
+        const local = lowerer.declareHiddenLocal("%bufferArgument", DYN);
+        const node = args[i];
+        const init = node === undefined ? dynUndefinedExpr(loc) : lowerer.lowerExprExpecting(node, DYN);
+        return { local, init };
+    });
+    const [source, second, third] = locals.map(({ local }) => varRef(local.id, DYN, loc));
+    const inNodeModules = /[\\/]node_modules[\\/]/.test(expr.getSourceFile().fileName);
+    const value = {
         kind: "ternary",
         cond: { kind: "dynTest", test: "number", value: source, type: BOOL, loc },
         then: {
             kind: "ternary",
-            cond: { kind: "dynTest", test: "string", value: encoding, type: BOOL, loc },
+            cond: { kind: "dynTest", test: "string", value: second, type: BOOL, loc },
             then: { kind: "libCall", fn: "buffer.newStringFail", args: [source], type: BYTES_U8, loc },
             else_: {
                 kind: "libCall",
@@ -1686,11 +1972,35 @@ export function lowerNodeModulesBufferConstruct(lowerer, expr) {
             type: BYTES_U8,
             loc,
         },
-        else_: dynBufferFromParts(source, encoding, loc),
+        else_: dynBufferFromParts(source, second, loc, third),
         type: BYTES_U8,
         loc,
-    }));
-    return { kind: "libCall", fn: "buffer.brand", args: [value], type: BYTES_U8, loc };
+    };
+    return {
+        kind: "seqExpr",
+        stmts: [
+            ...locals.map(({ local, init }) => ({
+                kind: "varDecl",
+                localId: local.id,
+                init,
+                loc,
+            })),
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: inNodeModules ? "buffer.deprecationCount" : "buffer.deprecation",
+                    args: [],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            },
+        ],
+        result: { kind: "libCall", fn: "buffer.brand", args: [value], type: BYTES_U8, loc },
+        type: BYTES_U8,
+        loc,
+    };
 }
 /** Buffer.from(array or bytes, extra): Node copies an array-like source and
  * ignores the encoding/offset argument (yazl passes its `encoding` through
@@ -1737,7 +2047,18 @@ function lowerBufferStaticValue(lowerer, call, access) {
             !args.some(ts.isSpreadElement) &&
             ((symbol) => symbol != null &&
                 (ts.symbolName(symbol) === "ArrayBuffer" || ts.symbolName(symbol) === "SharedArrayBuffer"))(lowerer.typeOf(args[0]).getSymbol())) {
-            return lowerArrayBufferView(lowerer, args, "u8", loc);
+            // A byte offset or length follows Node's fromArrayBuffer (its
+            // conversions and ERR_BUFFER_OUT_OF_BOUNDS), not the typed-array view.
+            if (args.length === 1)
+                return lowerArrayBufferView(lowerer, args, "u8", loc);
+            return bufferFromArrayBufferRange(lowerer, args, loc);
+        }
+        // Buffer.from(value, byteOffset, length) over an untyped value: an
+        // ArrayBuffer's range, or the two-argument conversion of other values.
+        if (args.length === 3 && !args.some(ts.isSpreadElement)) {
+            const first = lowerer.lowerExpr(args[0]);
+            if (first.type.kind === "dyn")
+                return bufferFromArrayBufferRange(lowerer, args, loc, first);
         }
         // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
         // x's storage (Node shares the ArrayBuffer; length is in BYTES).
@@ -2132,8 +2453,95 @@ function lowerBufferStaticValue(lowerer, call, access) {
             const s = lowerer.lowerExprExpecting(args[0], STRING);
             return { kind: "libCall", fn: "buffer.isEncoding", args: [s], type: BOOL, loc };
         }
-        lowerer.noLowering("Buffer.isEncoding with this argument shape", call, "one string-typed argument is the lowered form");
+        // Any other single argument: Node answers false for non-strings.
+        if (args.length === 1 && !ts.isSpreadElement(args[0])) {
+            const value = lowerer.declareHiddenLocal("%bufferEncoding", DYN);
+            const ref = varRef(value.id, DYN, loc);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    {
+                        kind: "varDecl",
+                        localId: value.id,
+                        init: lowerer.lowerExprExpecting(args[0], DYN),
+                        loc,
+                    },
+                ],
+                result: {
+                    kind: "logical",
+                    op: "&&",
+                    left: { kind: "dynTest", test: "string", value: ref, type: BOOL, loc },
+                    right: {
+                        kind: "libCall",
+                        fn: "buffer.isEncoding",
+                        args: [{ kind: "dynCheck", value: ref, type: STRING, loc }],
+                        type: BOOL,
+                        loc,
+                    },
+                    type: BOOL,
+                    loc,
+                },
+                type: BOOL,
+                loc,
+            };
+        }
+        lowerer.noLowering("Buffer.isEncoding with this argument shape", call, "one argument is the lowered form");
     }
     return null; // of, copyBytesFrom, ... → the SC2020 member fence
 }
+/** `Buffer.prototype.<name>` or `Buffer.prototype[key]` read in JavaScript
+ * (smart-buffer's `typeof Buffer.prototype[method]` probe): the member as
+ * scr_buffer_prototype_member answers it. Null for other expressions. */
+export function lowerBufferPrototypeMember(lowerer, expr) {
+    if (expr.questionDotToken || !isJsSourceFile(expr.getSourceFile()))
+        return null;
+    const receiver = expr.expression;
+    if (!ts.isPropertyAccessExpression(receiver) ||
+        receiver.questionDotToken ||
+        receiver.name.text !== "prototype" ||
+        stdlibGlobalNameOf(lowerer, receiver.expression) !== "Buffer")
+        return null;
+    const loc = locOf(expr);
+    const key = ts.isPropertyAccessExpression(expr)
+        ? {
+            kind: "dynFrom",
+            value: { kind: "strLit", value: expr.name.text, type: STRING, loc },
+            type: DYN,
+            loc,
+        }
+        : lowerer.lowerExprExpecting(expr.argumentExpression, DYN);
+    return { kind: "libCall", fn: "buffer.prototypeMember", args: [key], type: DYN, loc };
+}
+const BUFFER_VALUE_FNS = new Set([
+    "buffer.constructor",
+    "buffer.staticValue",
+    "buffer.prototypeMember",
+]);
+/** A program that reads the Buffer function's value installs it in %main,
+ * so a Buffer's `.constructor` answers the same function. */
+export function installBufferValue(functions) {
+    let found = false;
+    const visitor = {
+        expr: (e) => {
+            if (e.kind === "libCall" && BUFFER_VALUE_FNS.has(e.fn))
+                found = true;
+            return !found;
+        },
+        stmt: () => !found,
+    };
+    for (const fn of functions) {
+        for (const s of fn.body)
+            everyStmt(s, visitor);
+        if (found)
+            break;
+    }
+    const main = functions.find((fn) => fn.name === ENTRY_NAME);
+    if (!found || !main)
+        return;
+    main.body.unshift({
+        kind: "exprStmt",
+        expr: { kind: "libCall", fn: "buffer.installValue", args: [], type: VOID, loc: main.loc },
+        loc: main.loc,
+    });
+}
 //# sourceMappingURL=bytes.js.map