numbl 0.4.16 → 0.4.18

package/dist-cli/cli.js

@@ -23232,6 +23232,7 @@ function indexIntoRTValue(base, indices) {
       if (isRuntimeLogical(idx)) return idx === true;
       if (isRuntimeTensor(idx))
         return idx.data.length === 1 && Math.round(idx.data[0]) === 1;
+      if (isColonIndex(idx)) return true;
       return false;
     });
     if (allOnes) return base;
@@ -23243,6 +23244,9 @@ function indexIntoRTValue(base, indices) {
   if (isRuntimeStructArray(base)) {
     if (indices.length === 1) {
       const idx = indices[0];
+      if (isColonIndex(idx)) {
+        return RTV.structArray(base.fieldNames, [...base.elements]);
+      }
       if (isRuntimeNumber(idx)) {
         const i = Math.round(idx) - 1;
         if (i < 0 || i >= base.elements.length)
@@ -27570,7 +27574,7 @@ function sprintfFormat(fmt, args) {
       if (fmt[i] === "%" && i + 1 < fmt.length) {
         i++;
         let spec = "%";
-        while (i < fmt.length && !"dfigeEsoxXuc%".includes(fmt[i])) {
+        while (i < fmt.length && !"dfigGeEsoxXuc%".includes(fmt[i])) {
           if (fmt[i] === "*") {
             if (argIdx >= flatArgs.length) {
               outOfArgs = true;
@@ -27660,7 +27664,7 @@ function sprintfFormat(fmt, args) {
               const gPrec = precMatch ? parseInt(precMatch[1]) : 6;
               let gStr;
               if (gVal === 0) {
-                gStr = "0";
+                gStr = Object.is(gVal, -0) ? "-0" : "0";
               } else {
                 const exp2 = Math.floor(Math.log10(Math.abs(gVal)));
                 if (exp2 < -4 || exp2 >= gPrec) {
@@ -31936,6 +31940,9 @@ var ExpressionParser = class extends ParserBase {
       if (this.peekToken() === 50 /* LParen */ && this.inMatrixExpr && this.pos > 0 && !this.tokensAdjacent(this.pos - 1, this.pos)) {
         break;
       }
+      if (this.peekToken() === 54 /* LBrace */ && this.inMatrixExpr && this.pos > 0 && !this.tokensAdjacent(this.pos - 1, this.pos)) {
+        break;
+      }
       if (this.consume(50 /* LParen */)) {
         const start = expr.span.start;
         const args = [];
@@ -36810,14 +36817,20 @@ function dictRemove(d, keysArg) {
   }
   return RTV.dictionary(entries, d.keyType, d.valueType);
 }
-function dictLookup(d, keysArg) {
+function dictLookup(d, keysArg, fallbackValue) {
   const keys = expandKeys(keysArg);
   const results = [];
   for (const k of keys) {
     const coerced = d.keyType ? coerceKey(k, d.keyType) : k;
     const h = hashKey(coerced);
     const entry = d.entries.get(h);
-    if (!entry) throw new RuntimeError("Key not found in dictionary");
+    if (!entry) {
+      if (fallbackValue !== void 0) {
+        results.push(fallbackValue);
+        continue;
+      }
+      throw new RuntimeError("Key not found in dictionary");
+    }
     results.push(entry.value);
   }
   if (results.length === 1) return results[0];
@@ -37052,11 +37065,21 @@ registerIBuiltin({
 registerIBuiltin({
   name: "lookup",
   resolve: (argTypes) => {
-    if (argTypes.length !== 2 || argTypes[0].kind !== "dictionary") return null;
+    if (argTypes.length !== 2 && argTypes.length !== 4 || argTypes[0].kind !== "dictionary")
+      return null;
     return {
       outputTypes: [{ kind: "unknown" }],
       apply: (args) => {
         const d = args[0];
+        if (args.length === 4) {
+          const optName = isRuntimeChar(args[2]) ? args[2].value : isRuntimeString(args[2]) ? args[2] : "";
+          if (String(optName).toLowerCase() !== "fallbackvalue") {
+            throw new RuntimeError(
+              `Unrecognized option '${String(optName)}' for lookup`
+            );
+          }
+          return dictLookup(d, args[1], args[3]);
+        }
         return dictLookup(d, args[1]);
       }
     };
@@ -40184,33 +40207,66 @@ function registerSpecialBuiltins(rt) {
       };
     }
   });
+  const warningStateOff = /* @__PURE__ */ new Set();
   registerSpecial("warning", (nargout, args) => {
     if (args.length === 0) return nargout >= 1 ? RTV.num(0) : void 0;
     const margs = args.map((a) => ensureRuntimeValue(a));
+    const isOff = (id) => warningStateOff.has(id) || warningStateOff.has("all");
+    const stateStruct = (id) => RTV.struct(
+      /* @__PURE__ */ new Map([
+        ["identifier", RTV.char(id)],
+        ["state", RTV.char(isOff(id) ? "off" : "on")]
+      ])
+    );
+    const setState = (mode, id) => {
+      if (mode === "off") warningStateOff.add(id);
+      else {
+        warningStateOff.delete(id);
+        if (id === "all") warningStateOff.clear();
+      }
+    };
+    const restoreFrom = (s) => {
+      if (!isRuntimeStruct(s)) return false;
+      const idField = s.fields.get("identifier");
+      const stField = s.fields.get("state");
+      if (idField === void 0 || stField === void 0) return false;
+      setState(toString(stField), toString(idField));
+      return true;
+    };
+    if (margs.length === 1 && isRuntimeStruct(margs[0])) {
+      if (restoreFrom(margs[0])) return nargout >= 1 ? RTV.num(0) : void 0;
+    }
+    if (margs.length === 1 && isRuntimeStructArray(margs[0])) {
+      for (const el of margs[0].elements) restoreFrom(el);
+      return nargout >= 1 ? RTV.num(0) : void 0;
+    }
+    if (margs.length === 1 && isRuntimeChar(margs[0])) {
+      const mode = toString(margs[0]);
+      if (mode === "on" || mode === "off") {
+        const prev = stateStruct("all");
+        setState(mode, "all");
+        return nargout >= 1 ? prev : void 0;
+      }
+    }
     if (margs.length === 2 && isRuntimeChar(margs[0]) && isRuntimeChar(margs[1])) {
       const mode = toString(margs[0]);
+      const id = toString(margs[1]);
       if (mode === "on" || mode === "off") {
-        if (nargout === 0) return void 0;
-        return RTV.struct(
-          /* @__PURE__ */ new Map([
-            ["state", RTV.char("on")],
-            ["identifier", margs[1]]
-          ])
-        );
+        const prev = stateStruct(id);
+        setState(mode, id);
+        return nargout >= 1 ? prev : void 0;
       }
       if (mode === "query") {
-        return RTV.struct(
-          /* @__PURE__ */ new Map([
-            ["state", RTV.char("on")],
-            ["identifier", margs[1]]
-          ])
-        );
+        return stateStruct(id);
       }
     }
     let fmtIdx = 0;
     if (margs.length >= 2 && isRuntimeChar(margs[0]) && toString(margs[0]).includes(":")) {
       fmtIdx = 1;
     }
+    if (isOff(fmtIdx === 1 ? toString(margs[0]) : "all")) {
+      return nargout >= 1 ? RTV.num(0) : void 0;
+    }
     const fmt = toString(margs[fmtIdx]);
     const fmtArgs = [];
     for (let i = fmtIdx + 1; i < margs.length; i++) {
@@ -42747,7 +42803,7 @@ function _complexLuFactor(n, re, im, ipiv) {
 }
 
 // src/numbl-core/runtime/runtimeMemberAccess.ts
-function getMember(rt, base, name) {
+function getMember(rt, base, name, nargout = 1) {
   const mv = ensureRuntimeValue(base);
   if (isRuntimeClassInstance(mv)) {
     const accessorKey = `${mv.className}.get.${name}`;
@@ -42766,7 +42822,7 @@ function getMember(rt, base, name) {
     if (field !== void 0) return field;
     const method = rt.cachedResolveClassMethod(mv.className, name);
     if (method) {
-      return method(1, base);
+      return method(nargout, base);
     }
     const guardKey = `${mv.className}.subsref`;
     if (!rt.activeAccessors.has(guardKey)) {
@@ -45470,8 +45526,8 @@ var Runtime = class _Runtime {
     return multiOutputCellAssign(base, indices, results, this);
   }
   // ── Member access ───────────────────────────────────────────────────
-  getMember(base, name) {
-    return getMember(this, base, name);
+  getMember(base, name, nargout = 1) {
+    return getMember(this, base, name, nargout);
   }
   getMemberDynamic(base, nameExpr) {
     return getMemberDynamic(this, base, nameExpr);
@@ -51363,6 +51419,46 @@ function uniquetolElements(v, nargout, tol) {
   if (nargout === 2) return [C, ia];
   return [C, ia, icTensor];
 }
+defineBuiltin({
+  name: "ismembc2",
+  cases: [
+    {
+      match: (argTypes) => {
+        if (argTypes.length !== 2) return null;
+        return [{ kind: "tensor", isComplex: false }];
+      },
+      apply: (args) => {
+        const toFlat = (v) => {
+          if (isRuntimeNumber(v)) return [v];
+          if (isRuntimeLogical(v)) return [v ? 1 : 0];
+          if (isRuntimeTensor(v)) return v.data;
+          throw new RuntimeError("ismembc2: arguments must be numeric");
+        };
+        const a = toFlat(args[0]);
+        const s = toFlat(args[1]);
+        const out = allocFloat64Array(a.length);
+        for (let i = 0; i < a.length; i++) {
+          const x = a[i];
+          let lo = 0;
+          let hi = s.length - 1;
+          let res = 0;
+          while (lo <= hi) {
+            const mid = lo + hi >> 1;
+            if (s[mid] <= x) {
+              if (s[mid] === x) res = mid + 1;
+              lo = mid + 1;
+            } else {
+              hi = mid - 1;
+            }
+          }
+          out[i] = res;
+        }
+        const shape = isRuntimeTensor(args[0]) ? [...args[0].shape] : [1, 1];
+        return RTV.tensor(out, shape);
+      }
+    }
+  ]
+});
 
 // src/numbl-core/interpreter/builtins/linear-algebra.ts
 function isNumericJitType(t) {
@@ -57541,6 +57637,45 @@ defineBuiltin({
       },
       apply: (args) => {
         const xArr = toFloatArray(args[0]);
+        if (args.length === 4 && isRuntimeChar(args[2]) && isRuntimeChar(args[3]) && args[3].value.toLowerCase() === "pp") {
+          const method2 = args[2].value.toLowerCase();
+          if (method2 !== "linear")
+            throw new RuntimeError(
+              `interp1: 'pp' output is only supported for 'linear' method (got '${method2}')`
+            );
+          const yArr = toFloatArray(args[1]);
+          const n = xArr.length;
+          if (yArr.length !== n)
+            throw new RuntimeError(
+              "interp1: x and y must have the same length"
+            );
+          if (n < 2)
+            throw new RuntimeError(
+              "interp1: at least 2 sample points are required"
+            );
+          for (let i = 0; i + 1 < n; i++) {
+            if (!(xArr[i] < xArr[i + 1]))
+              throw new RuntimeError(
+                "interp1: sample points must be unique and sorted for 'pp' output"
+              );
+          }
+          const L = n - 1;
+          const breaksOut = allocFloat64Array(n);
+          for (let i = 0; i < n; i++) breaksOut[i] = xArr[i];
+          const coefs = allocFloat64Array(L * 2);
+          for (let i = 0; i < L; i++) {
+            coefs[i] = (yArr[i + 1] - yArr[i]) / (xArr[i + 1] - xArr[i]);
+            coefs[L + i] = yArr[i];
+          }
+          const fields = /* @__PURE__ */ new Map();
+          fields.set("form", "pp");
+          fields.set("breaks", RTV.tensor(breaksOut, [1, n]));
+          fields.set("coefs", RTV.tensor(coefs, [L, 2]));
+          fields.set("pieces", L);
+          fields.set("order", 2);
+          fields.set("dim", 1);
+          return RTV.struct(fields);
+        }
         const xqArg = args[2];
         const nn = xArr.length;
         const yVal = args[1];
@@ -57569,6 +57704,7 @@ defineBuiltin({
           throw new RuntimeError("interp1: x and y must have the same length");
         let method = "linear";
         let doExtrap = false;
+        let fillValue = NaN;
         for (let i = 3; i < args.length; i++) {
           const a = args[i];
           if (isRuntimeChar(a)) {
@@ -57579,11 +57715,13 @@ defineBuiltin({
             const s = a.toLowerCase();
             if (s === "extrap") doExtrap = true;
             else method = s;
+          } else if (isRuntimeNumber(a) || isRuntimeTensor(a)) {
+            fillValue = toNumber(a);
           }
         }
         const interpOne = (yArr, xq) => {
           if (xq < xArr[0] || xq > xArr[nn - 1]) {
-            if (!doExtrap) return NaN;
+            if (!doExtrap) return fillValue;
             if (method === "linear") {
               if (xq < xArr[0]) {
                 const slope = (yArr[1] - yArr[0]) / (xArr[1] - xArr[0]);
@@ -58014,6 +58152,63 @@ function dimArgToVec(v) {
   }
   throw new RuntimeError("mkpp: dim must be a numeric scalar or vector");
 }
+var ppIntApply = (fname) => (args) => {
+  const pp = args[0];
+  if (!isRuntimeStruct(pp))
+    throw new RuntimeError(`${fname}: argument must be a pp struct`);
+  const breaksRT = pp.fields.get("breaks");
+  const coefsRT = pp.fields.get("coefs");
+  const piecesRT = pp.fields.get("pieces");
+  const orderRT = pp.fields.get("order");
+  const dimRT = pp.fields.get("dim");
+  if (breaksRT === void 0 || coefsRT === void 0 || piecesRT === void 0 || orderRT === void 0)
+    throw new RuntimeError(`${fname}: pp struct missing required fields`);
+  const breaks = toFloatArray(breaksRT);
+  const L = Math.round(toNumber(piecesRT));
+  const k = Math.round(toNumber(orderRT));
+  const dim = dimRT === void 0 ? [1] : dimArgToVec(dimRT);
+  if (dim.reduce((a, b) => a * b, 1) !== 1)
+    throw new RuntimeError(`${fname}: only scalar-valued pp is supported`);
+  if (!isRuntimeTensor(coefsRT))
+    throw new RuntimeError(`${fname}: pp.coefs must be a matrix`);
+  const coefs = coefsRT.data;
+  const out = allocFloat64Array(L * (k + 1));
+  for (let c = 0; c < k; c++) {
+    for (let i = 0; i < L; i++) out[c * L + i] = coefs[c * L + i] / (k - c);
+  }
+  let A = 0;
+  for (let i = 0; i < L; i++) {
+    out[k * L + i] = A;
+    const h = breaks[i + 1] - breaks[i];
+    let v = out[0 * L + i];
+    for (let c = 1; c <= k; c++) v = v * h + out[c * L + i];
+    A = v;
+  }
+  const fields = /* @__PURE__ */ new Map();
+  fields.set("form", "pp");
+  const breaksOut = allocFloat64Array(breaks.length);
+  for (let i = 0; i < breaks.length; i++) breaksOut[i] = breaks[i];
+  fields.set("breaks", RTV.tensor(breaksOut, [1, breaks.length]));
+  fields.set("coefs", RTV.tensor(out, [L, k + 1]));
+  fields.set("pieces", L);
+  fields.set("order", k + 1);
+  fields.set("dim", 1);
+  return RTV.struct(fields);
+};
+for (const fname of ["fnint", "ppint"]) {
+  defineBuiltin({
+    name: fname,
+    cases: [
+      {
+        match: (argTypes) => {
+          if (argTypes.length !== 1) return null;
+          return [{ kind: "struct", fields: {} }];
+        },
+        apply: ppIntApply(fname)
+      }
+    ]
+  });
+}
 defineBuiltin({
   name: "mkpp",
   cases: [
@@ -58755,6 +58950,8 @@ defineBuiltin({
     {
       match: (argTypes) => {
         if (argTypes.length === 0) return [{ kind: "struct", fields: {} }];
+        if (argTypes.length === 1 && argTypes[0].kind === "tensor")
+          return [{ kind: "struct", fields: {} }];
         if (argTypes.length % 2 !== 0) return null;
         for (let i = 0; i < argTypes.length; i += 2) {
           const k = argTypes[i].kind;
@@ -58764,6 +58961,13 @@ defineBuiltin({
       },
       apply: (args) => {
         if (args.length === 0) return RTV.struct(/* @__PURE__ */ new Map());
+        if (args.length === 1 && isRuntimeTensor(args[0])) {
+          if (args[0].data.length !== 0)
+            throw new RuntimeError(
+              "struct: single non-empty numeric argument is not supported"
+            );
+          return RTV.structArray([], []);
+        }
         if (args.length % 2 !== 0)
           throw new RuntimeError("struct: requires field-value pairs");
         const fieldNames = [];
@@ -59556,13 +59760,48 @@ registerIBuiltin({
   resolve: (argTypes) => {
     if (argTypes.length !== 1) return null;
     return {
-      outputTypes: [{ kind: "tensor", isComplex: false }],
+      outputTypes: [{ kind: "unknown" }],
       apply: (args) => {
         const C = args[0];
         if (!isRuntimeCell(C))
           throw new RuntimeError("cell2mat: argument must be a cell array");
         const cellRows = C.shape[0];
         const cellCols = C.shape.length >= 2 ? C.shape[1] : 1;
+        if (C.data.length > 0 && C.data.some((v) => isRuntimeChar(v))) {
+          const asCharBlock = (v) => {
+            if (!isRuntimeChar(v))
+              throw new RuntimeError(
+                "cell2mat: cannot mix char and non-char cell contents"
+              );
+            const rows = v.shape ? v.shape[0] : v.value.length === 0 ? 0 : 1;
+            const cols = v.shape ? v.shape[1] : v.value.length;
+            const rowStrings = [];
+            for (let r = 0; r < rows; r++)
+              rowStrings.push(v.value.slice(r * cols, (r + 1) * cols));
+            return { rows, cols, rowStrings };
+          };
+          const outRows = [];
+          for (let ci = 0; ci < cellRows; ci++) {
+            const blockHeight = asCharBlock(C.data[ci]).rows;
+            const lines = new Array(blockHeight).fill("");
+            for (let cj = 0; cj < cellCols; cj++) {
+              const b = asCharBlock(C.data[cj * cellRows + ci]);
+              if (b.rows !== blockHeight)
+                throw new RuntimeError(
+                  "cell2mat: inconsistent cell content sizes"
+                );
+              for (let r = 0; r < blockHeight; r++) lines[r] += b.rowStrings[r];
+            }
+            outRows.push(...lines);
+          }
+          const width = outRows.length > 0 ? outRows[0].length : 0;
+          if (outRows.some((r) => r.length !== width))
+            throw new RuntimeError("cell2mat: inconsistent cell content sizes");
+          if (outRows.length <= 1) return RTV.char(outRows[0] ?? "");
+          const rc = RTV.char(outRows.join(""));
+          rc.shape = [outRows.length, width];
+          return rc;
+        }
         const asTensor = (v) => {
           if (isRuntimeNumber(v))
             return {
@@ -62085,6 +62324,288 @@ defineBuiltin({
   ]
 });
 
+// src/numbl-core/interpreter/builtins/hash.ts
+function valueToByteString(v) {
+  if (isRuntimeChar(v)) return v.value;
+  if (isRuntimeString(v)) return String(v);
+  throw new RuntimeError("hash: STR must be a char array or string");
+}
+function md5Hex(input) {
+  const bytes = [];
+  for (let i = 0; i < input.length; i++) bytes.push(input.charCodeAt(i) & 255);
+  const origLenBits = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) bytes.push(0);
+  let len = origLenBits;
+  for (let i = 0; i < 8; i++) {
+    bytes.push(len & 255);
+    len = Math.floor(len / 256);
+  }
+  const S = [
+    7,
+    12,
+    17,
+    22,
+    7,
+    12,
+    17,
+    22,
+    7,
+    12,
+    17,
+    22,
+    7,
+    12,
+    17,
+    22,
+    5,
+    9,
+    14,
+    20,
+    5,
+    9,
+    14,
+    20,
+    5,
+    9,
+    14,
+    20,
+    5,
+    9,
+    14,
+    20,
+    4,
+    11,
+    16,
+    23,
+    4,
+    11,
+    16,
+    23,
+    4,
+    11,
+    16,
+    23,
+    4,
+    11,
+    16,
+    23,
+    6,
+    10,
+    15,
+    21,
+    6,
+    10,
+    15,
+    21,
+    6,
+    10,
+    15,
+    21,
+    6,
+    10,
+    15,
+    21
+  ];
+  const K = new Array(64);
+  for (let i = 0; i < 64; i++)
+    K[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296) >>> 0;
+  let a0 = 1732584193;
+  let b0 = 4023233417;
+  let c0 = 2562383102;
+  let d0 = 271733878;
+  const rotl2 = (x, c) => (x << c | x >>> 32 - c) >>> 0;
+  for (let chunk = 0; chunk < bytes.length; chunk += 64) {
+    const M = new Array(16);
+    for (let j = 0; j < 16; j++) {
+      const o = chunk + j * 4;
+      M[j] = (bytes[o] | bytes[o + 1] << 8 | bytes[o + 2] << 16 | bytes[o + 3] << 24) >>> 0;
+    }
+    let A = a0;
+    let B = b0;
+    let C = c0;
+    let D = d0;
+    for (let i = 0; i < 64; i++) {
+      let F;
+      let g;
+      if (i < 16) {
+        F = B & C | ~B & D;
+        g = i;
+      } else if (i < 32) {
+        F = D & B | ~D & C;
+        g = (5 * i + 1) % 16;
+      } else if (i < 48) {
+        F = B ^ C ^ D;
+        g = (3 * i + 5) % 16;
+      } else {
+        F = C ^ (B | ~D);
+        g = 7 * i % 16;
+      }
+      F = F + A + K[i] + M[g] >>> 0;
+      A = D;
+      D = C;
+      C = B;
+      B = B + rotl2(F, S[i]) >>> 0;
+    }
+    a0 = a0 + A >>> 0;
+    b0 = b0 + B >>> 0;
+    c0 = c0 + C >>> 0;
+    d0 = d0 + D >>> 0;
+  }
+  const le2 = (w) => {
+    let s = "";
+    for (let i = 0; i < 4; i++)
+      s += (w >>> i * 8 & 255).toString(16).padStart(2, "0");
+    return s;
+  };
+  return le2(a0) + le2(b0) + le2(c0) + le2(d0);
+}
+function sha256Hex(input) {
+  const bytes = [];
+  for (let i = 0; i < input.length; i++) bytes.push(input.charCodeAt(i) & 255);
+  const origLenBits = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) bytes.push(0);
+  const hi = Math.floor(origLenBits / 4294967296);
+  const lo = origLenBits >>> 0;
+  for (let i = 3; i >= 0; i--) bytes.push(hi >>> i * 8 & 255);
+  for (let i = 3; i >= 0; i--) bytes.push(lo >>> i * 8 & 255);
+  const K = [
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ];
+  const H2 = [
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ];
+  const rotr = (x, c) => (x >>> c | x << 32 - c) >>> 0;
+  for (let chunk = 0; chunk < bytes.length; chunk += 64) {
+    const W = new Array(64);
+    for (let j = 0; j < 16; j++) {
+      const o = chunk + j * 4;
+      W[j] = (bytes[o] << 24 | bytes[o + 1] << 16 | bytes[o + 2] << 8 | bytes[o + 3]) >>> 0;
+    }
+    for (let j = 16; j < 64; j++) {
+      const s0 = rotr(W[j - 15], 7) ^ rotr(W[j - 15], 18) ^ W[j - 15] >>> 3;
+      const s1 = rotr(W[j - 2], 17) ^ rotr(W[j - 2], 19) ^ W[j - 2] >>> 10;
+      W[j] = W[j - 16] + s0 + W[j - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = H2;
+    for (let j = 0; j < 64; j++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = h + S1 + ch + K[j] + W[j] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    H2[0] = H2[0] + a >>> 0;
+    H2[1] = H2[1] + b >>> 0;
+    H2[2] = H2[2] + c >>> 0;
+    H2[3] = H2[3] + d >>> 0;
+    H2[4] = H2[4] + e >>> 0;
+    H2[5] = H2[5] + f >>> 0;
+    H2[6] = H2[6] + g >>> 0;
+    H2[7] = H2[7] + h >>> 0;
+  }
+  return H2.map((w) => (w >>> 0).toString(16).padStart(8, "0")).join("");
+}
+registerIBuiltin({
+  name: "hash",
+  resolve: (argTypes) => {
+    if (argTypes.length !== 2) return null;
+    return {
+      outputTypes: [{ kind: "char" }],
+      apply: (args) => {
+        const algoRaw = valueToByteString(args[0]);
+        const algo = algoRaw.toUpperCase().replace(/-/g, "");
+        const msg = valueToByteString(args[1]);
+        if (algo === "MD5") return RTV.char(md5Hex(msg));
+        if (algo === "SHA256") return RTV.char(sha256Hex(msg));
+        throw new RuntimeError(
+          `hash: unsupported hash function '${algoRaw}' (supported: MD5, SHA256)`
+        );
+      }
+    };
+  }
+});
+
 // src/numbl-core/interpreter/builtins/help-text.ts
 var H = {
   // ── Math ──────────────────────────────────────────────────────────────
@@ -64277,7 +64798,7 @@ function getSourceLine(getSource, file, line) {
 }
 
 // src/numbl-core/version.ts
-var NUMBL_VERSION = "0.4.16";
+var NUMBL_VERSION = "0.4.18";
 
 // src/cli-repl.ts
 import { createInterface } from "readline";
@@ -66920,7 +67441,7 @@ function evalMember(expr, nargout) {
       (el) => ensureRuntimeValue(this.rt.getMember(el, expr.name))
     );
   }
-  return this.rt.getMember(base, expr.name);
+  return this.rt.getMember(base, expr.name, nargout);
 }
 function tryExtractDottedName(expr) {
   if (expr.type === "Ident") return expr.name;
@@ -66931,7 +67452,14 @@ function tryExtractDottedName(expr) {
   return null;
 }
 function evalIndex(expr) {
-  const base = this.evalExpr(expr.base);
+  let base = this.evalExpr(expr.base);
+  if (Array.isArray(base)) {
+    if (base.length === 1) base = base[0];
+    else
+      throw new RuntimeError(
+        `Expression produced ${base.length} values where one was expected`
+      );
+  }
   const indices = this.evalIndicesWithEnd(base, expr.indices);
   let skipSubsref = false;
   if (this.currentClassName) {
@@ -67317,7 +67845,12 @@ function evalLValueBase(base, defaultVal) {
     }
     const indices = this.evalIndicesWithEnd(baseVal, base.indices);
     try {
-      return this.rt.indexCell(baseVal, indices);
+      const result = this.rt.indexCell(baseVal, indices);
+      if (Array.isArray(result)) {
+        if (result.length === 1) return result[0];
+        if (result.length === 0) return defaultVal;
+      }
+      return result;
     } catch {
       return defaultVal;
     }
@@ -70016,7 +70549,11 @@ var stdlibFiles = [
   },
   {
     name: "inputParser.m",
-    source: "classdef inputParser < handle\n    properties\n        CaseSensitive = false\n        FunctionName = ''\n        KeepUnmatched = false\n        PartialMatching = true\n        StructExpand = true\n        Results = struct()\n        Unmatched = struct()\n        UsingDefaults = {}\n        Parameters = {}\n    end\n    properties\n        required_ = {}\n        optional_ = {}\n        params_ = {}\n    end\n    methods\n        function addRequired(obj, name, validator)\n            if nargin < 3\n                validator = [];\n            end\n            entry = struct('name', name, 'default', {[]}, 'validator', {{}});\n            if ~isempty(validator)\n                entry.validator = validator;\n            end\n            obj.required_{end+1} = entry;\n            obj.Parameters{end+1} = name;\n        end\n\n        function addOptional(obj, name, default, validator)\n            if nargin < 4\n                validator = [];\n            end\n            entry = struct('name', name, 'default', {default}, 'validator', {{}});\n            if ~isempty(validator)\n                entry.validator = validator;\n            end\n            obj.optional_{end+1} = entry;\n            obj.Parameters{end+1} = name;\n        end\n\n        function addParameter(obj, name, default, validator)\n            if nargin < 4\n                validator = [];\n            end\n            entry = struct('name', name, 'default', {default}, 'validator', {{}});\n            if ~isempty(validator)\n                entry.validator = validator;\n            end\n            obj.params_{end+1} = entry;\n            obj.Parameters{end+1} = name;\n        end\n\n        function addParamValue(obj, name, default, validator)\n            addParameter(obj, name, default, validator);\n        end\n\n        function parse(obj, varargin)\n            s = struct();\n            usingDefaults = {};\n            pos = 1;\n            nargs = numel(varargin);\n\n            % Parse required arguments\n            for i = 1:numel(obj.required_)\n                entry = obj.required_{i};\n                if pos > nargs\n                    error('Not enough input arguments. Missing required argument ''%s''.', entry.name);\n                end\n                val = varargin{pos};\n                pos = pos + 1;\n                s.(entry.name) = val;\n            end\n\n            % Parse optional positional arguments\n            % An optional arg is consumed only if it is NOT a string matching a parameter name\n            for i = 1:numel(obj.optional_)\n                entry = obj.optional_{i};\n                if pos <= nargs\n                    nextVal = varargin{pos};\n                    isParamName = false;\n                    if ischar(nextVal) || isstring(nextVal)\n                        paramName = char(nextVal);\n                        for k = 1:numel(obj.params_)\n                            pentry = obj.params_{k};\n                            if inputParser.namesMatch(paramName, pentry.name, obj.CaseSensitive)\n                                isParamName = true;\n                                break;\n                            end\n                        end\n                    end\n                    if ~isParamName\n                        s.(entry.name) = nextVal;\n                        pos = pos + 1;\n                    else\n                        s.(entry.name) = entry.default;\n                        usingDefaults{end+1} = entry.name;\n                    end\n                else\n                    s.(entry.name) = entry.default;\n                    usingDefaults{end+1} = entry.name;\n                end\n            end\n\n            % Set defaults for all parameters\n            for i = 1:numel(obj.params_)\n                entry = obj.params_{i};\n                s.(entry.name) = entry.default;\n                usingDefaults{end+1} = entry.name;\n            end\n\n            % Parse name-value pairs from remaining arguments\n            unmatched = struct();\n            while pos <= nargs\n                if pos + 1 > nargs\n                    error('Expected name-value pair argument.');\n                end\n                name = varargin{pos};\n                val = varargin{pos + 1};\n                pos = pos + 2;\n\n                if ~ischar(name) && ~isstring(name)\n                    error('Expected parameter name to be a string.');\n                end\n                name = char(name);\n\n                found = false;\n                for i = 1:numel(obj.params_)\n                    entry = obj.params_{i};\n                    if inputParser.namesMatch(name, entry.name, obj.CaseSensitive)\n                        s.(entry.name) = val;\n                        % Remove from usingDefaults\n                        newDefaults = {};\n                        for j = 1:numel(usingDefaults)\n                            if ~strcmp(usingDefaults{j}, entry.name)\n                                newDefaults{end+1} = usingDefaults{j};\n                            end\n                        end\n                        usingDefaults = newDefaults;\n                        found = true;\n                        break;\n                    end\n                end\n                if ~found\n                    if obj.KeepUnmatched\n                        unmatched.(name) = val;\n                    else\n                        error('''%s'' is not a recognized parameter.', name);\n                    end\n                end\n            end\n\n            obj.Results = s;\n            obj.UsingDefaults = usingDefaults;\n            obj.Unmatched = unmatched;\n        end\n    end\n\n    methods (Static)\n        function tf = namesMatch(input, expected, caseSensitive)\n            if caseSensitive\n                tf = strcmp(input, expected);\n            else\n                tf = strcmpi(input, expected);\n            end\n        end\n    end\nend\n"
+    source: "classdef inputParser < handle\n    properties\n        CaseSensitive = false\n        FunctionName = ''\n        KeepUnmatched = false\n        PartialMatching = true\n        StructExpand = true\n        Results = struct()\n        Unmatched = struct()\n        UsingDefaults = {}\n        Parameters = {}\n    end\n    properties\n        required_ = {}\n        optional_ = {}\n        params_ = {}\n    end\n    methods\n        function addRequired(obj, name, validator)\n            if nargin < 3\n                validator = [];\n            end\n            entry = struct('name', name, 'default', {[]}, 'validator', {{}});\n            if ~isempty(validator)\n                entry.validator = validator;\n            end\n            obj.required_{end+1} = entry;\n            obj.Parameters{end+1} = name;\n        end\n\n        function addOptional(obj, name, default, validator)\n            if nargin < 4\n                validator = [];\n            end\n            entry = struct('name', name, 'default', {default}, 'validator', {{}});\n            if ~isempty(validator)\n                entry.validator = validator;\n            end\n            obj.optional_{end+1} = entry;\n            obj.Parameters{end+1} = name;\n        end\n\n        function addParameter(obj, name, default, validator)\n            if nargin < 4\n                validator = [];\n            end\n            entry = struct('name', name, 'default', {default}, 'validator', {{}});\n            if ~isempty(validator)\n                entry.validator = validator;\n            end\n            obj.params_{end+1} = entry;\n            obj.Parameters{end+1} = name;\n        end\n\n        function addParamValue(obj, name, default, validator)\n            if nargin < 4\n                addParameter(obj, name, default);\n            else\n                addParameter(obj, name, default, validator);\n            end\n        end\n\n        function parse(obj, varargin)\n            s = struct();\n            usingDefaults = {};\n            pos = 1;\n            nargs = numel(varargin);\n\n            % Parse required arguments\n            for i = 1:numel(obj.required_)\n                entry = obj.required_{i};\n                if pos > nargs\n                    error('Not enough input arguments. Missing required argument ''%s''.', entry.name);\n                end\n                val = varargin{pos};\n                pos = pos + 1;\n                s.(entry.name) = val;\n            end\n\n            % Parse optional positional arguments\n            % An optional arg is consumed only if it is NOT a string matching a\n            % parameter or optional name (MATLAB also accepts optionals as\n            % name-value pairs, so their names terminate positional parsing)\n            for i = 1:numel(obj.optional_)\n                entry = obj.optional_{i};\n                if pos <= nargs\n                    nextVal = varargin{pos};\n                    isParamName = false;\n                    if ischar(nextVal) || isstring(nextVal)\n                        paramName = char(nextVal);\n                        for k = 1:numel(obj.params_)\n                            pentry = obj.params_{k};\n                            if inputParser.namesMatch(paramName, pentry.name, obj.CaseSensitive)\n                                isParamName = true;\n                                break;\n                            end\n                        end\n                        if ~isParamName\n                            for k = 1:numel(obj.optional_)\n                                oentry = obj.optional_{k};\n                                if inputParser.namesMatch(paramName, oentry.name, obj.CaseSensitive)\n                                    isParamName = true;\n                                    break;\n                                end\n                            end\n                        end\n                    end\n                    if ~isParamName\n                        s.(entry.name) = nextVal;\n                        pos = pos + 1;\n                    else\n                        s.(entry.name) = entry.default;\n                        usingDefaults{end+1} = entry.name;\n                    end\n                else\n                    s.(entry.name) = entry.default;\n                    usingDefaults{end+1} = entry.name;\n                end\n            end\n\n            % Set defaults for all parameters\n            for i = 1:numel(obj.params_)\n                entry = obj.params_{i};\n                s.(entry.name) = entry.default;\n                usingDefaults{end+1} = entry.name;\n            end\n\n            % Parse name-value pairs from remaining arguments\n            unmatched = struct();\n            while pos <= nargs\n                if pos + 1 > nargs\n                    error('Expected name-value pair argument.');\n                end\n                name = varargin{pos};\n                val = varargin{pos + 1};\n                pos = pos + 2;\n\n                if ~ischar(name) && ~isstring(name)\n                    error('Expected parameter name to be a string.');\n                end\n                name = char(name);\n\n                found = false;\n                % Optionals may also be passed by name (undocumented MATLAB\n                % behavior relied on by real-world code)\n                candidates = [obj.params_, obj.optional_];\n                for i = 1:numel(candidates)\n                    entry = candidates{i};\n                    if inputParser.namesMatch(name, entry.name, obj.CaseSensitive)\n                        s.(entry.name) = val;\n                        % Remove from usingDefaults\n                        newDefaults = {};\n                        for j = 1:numel(usingDefaults)\n                            if ~strcmp(usingDefaults{j}, entry.name)\n                                newDefaults{end+1} = usingDefaults{j};\n                            end\n                        end\n                        usingDefaults = newDefaults;\n                        found = true;\n                        break;\n                    end\n                end\n                if ~found\n                    if obj.KeepUnmatched\n                        unmatched.(name) = val;\n                    else\n                        error('''%s'' is not a recognized parameter.', name);\n                    end\n                end\n            end\n\n            obj.Results = s;\n            obj.UsingDefaults = usingDefaults;\n            obj.Unmatched = unmatched;\n        end\n    end\n\n    methods (Static)\n        function tf = namesMatch(input, expected, caseSensitive)\n            if caseSensitive\n                tf = strcmp(input, expected);\n            else\n                tf = strcmpi(input, expected);\n            end\n        end\n    end\nend\n"
+  },
+  {
+    name: "normalize.m",
+    source: "function Y = normalize(X, method, p)\n    % normalize(X)            z-score along the first non-singleton dimension\n    % normalize(X, 'zscore')  same as above\n    % normalize(X, 'norm')    divide by the 2-norm along that dimension\n    % normalize(X, 'norm', p) divide by the p-norm (p = Inf -> max abs)\n    if nargin < 2\n        method = 'zscore';\n    end\n    if size(X, 1) == 1\n        dim = 2;\n    else\n        dim = 1;\n    end\n    switch lower(method)\n        case 'zscore'\n            mu = mean(X, dim);\n            sigma = std(X, 0, dim);\n            Y = (X - mu) ./ sigma;\n        case 'norm'\n            if nargin < 3\n                p = 2;\n            end\n            if isinf(p)\n                n = max(abs(X), [], dim);\n            else\n                n = sum(abs(X) .^ p, dim) .^ (1 / p);\n            end\n            Y = X ./ n;\n        otherwise\n            error('normalize: unsupported method ''%s''', method);\n    end\nend\n"
   },
   {
     name: "parse.m",
@@ -70207,6 +70744,7 @@ var shimFiles = [
         end
 
         function result = keys(obj)
+            % MATLAB's containers.Map returns keys in sorted order
             if obj.Count == 0
                 result = {};
                 return;
@@ -70222,6 +70760,8 @@ var shimFiles = [
                 for i = 1:numel(k)
                     result{i} = char(k{i});
                 end
+                % MATLAB returns a sorted 1xN row cell
+                result = reshape(sort(result), 1, []);
             else
                 % Numeric keys: parse back from string
                 if iscell(k)
@@ -70232,17 +70772,27 @@ var shimFiles = [
                 else
                     result = {str2double(k)};
                 end
+                result = reshape(num2cell(sort(cell2mat(result))), 1, []);
             end
         end
 
         function result = values(obj)
+            % Ordered to correspond with keys() (i.e. key-sorted)
             if obj.Count == 0
                 result = {};
                 return;
             end
-            v = values(obj.data_);
+            sortedKeys = keys(obj);
+            v = cell(1, obj.Count);
+            for i = 1:obj.Count
+                v{i} = obj.data_(makeKey(sortedKeys{i}, obj.KeyType));
+            end
             if strcmp(obj.ValueType, 'any')
-                result = v;
+                % Values are stored cell-wrapped (see subsasgn); unwrap each
+                result = cell(1, obj.Count);
+                for i = 1:obj.Count
+                    result{i} = v{i}{1};
+                end
             else
                 if iscell(v)
                     result = v;