@barefootjs/jinja 0.18.4 → 0.18.7

package/dist/index.js

@@ -187308,7 +187308,13 @@ import {
   prepareLoweringMatchers,
   queryHrefArgs,
   isValidHelperId,
-  sortComparatorFromArrow as sortComparatorFromArrow2
+  sortComparatorFromArrow as sortComparatorFromArrow2,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  resolveStaticLoopSource,
+  collectLoopBoundNames
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -187369,7 +187375,7 @@ function isAriaBooleanAttr(name) {
 }
 
 // src/adapter/jinja-adapter.ts
-import { BF_SLOT, BF_COND, BF_REGION } from "@barefootjs/shared";
+import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } from "@barefootjs/shared";
 
 // src/adapter/lib/constants.ts
 var JINJA_TEMPLATE_PRIMITIVES = {
@@ -187378,7 +187384,10 @@ var JINJA_TEMPLATE_PRIMITIVES = {
   Number: { arity: 1, emit: (args) => `bf.number(${args[0]})` },
   "Math.floor": { arity: 1, emit: (args) => `bf.floor(${args[0]})` },
   "Math.ceil": { arity: 1, emit: (args) => `bf.ceil(${args[0]})` },
-  "Math.round": { arity: 1, emit: (args) => `bf.round(${args[0]})` }
+  "Math.round": { arity: 1, emit: (args) => `bf.round(${args[0]})` },
+  "Math.min": { arity: 2, emit: (args) => `bf.min(${args[0]}, ${args[1]})` },
+  "Math.max": { arity: 2, emit: (args) => `bf.max(${args[0]}, ${args[1]})` },
+  "Math.abs": { arity: 1, emit: (args) => `bf.abs(${args[0]})` }
 };
 var JINJA_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(JINJA_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
 
@@ -187557,6 +187566,12 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf.trim(${recv})`;
     }
+    case "trimStart":
+    case "trimEnd": {
+      const fn = method === "trimStart" ? "trim_start" : "trim_end";
+      const recv = emit(object);
+      return `bf.${fn}(${recv})`;
+    }
     case "toFixed": {
       const recv = emit(object);
       const digits = args.length >= 1 ? emit(args[0]) : "0";
@@ -187590,6 +187605,12 @@ function renderArrayMethod(method, object, args, emit) {
       const newS = emit(args[1]);
       return `bf.replace(${recv}, ${oldS}, ${newS})`;
     }
+    case "replaceAll": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf.replace_all(${recv}, ${oldS}, ${newS})`;
+    }
     case "repeat": {
       const recv = emit(object);
       const count = args.length === 0 ? "0" : emit(args[0]);
@@ -187684,6 +187705,39 @@ function renderFlatMethod(recv, depth, emit) {
   return `bf.flat(${recv}, ${d})`;
 }
 
+// src/adapter/lib/static-value.ts
+function staticValueToJinja(value) {
+  if (value === null || value === undefined)
+    return "none";
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string")
+    return `'${escapeJinjaSingleQuoted(value)}'`;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const el of value) {
+      const serialized = staticValueToJinja(el);
+      if (serialized === null)
+        return null;
+      items.push(serialized);
+    }
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = [];
+    for (const [key, val] of Object.entries(value)) {
+      const serialized = staticValueToJinja(val);
+      if (serialized === null)
+        return null;
+      entries.push(`${jinjaHashKey(key)}: ${serialized}`);
+    }
+    return `{${entries.join(", ")}}`;
+  }
+  return null;
+}
+
 // src/adapter/expr/emitters.ts
 import {
   groupBinaryOperand,
@@ -187732,11 +187786,11 @@ class JinjaFilterEmitter {
       return "none";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, _optional, emit) {
     if (property === "length") {
       return `bf.length(${emit(object)})`;
     }
-    return `${emit(object)}.${property}`;
+    return `${emit(object)}['${escapeJinjaSingleQuoted(property)}']`;
   }
   indexAccess(object, index, emit) {
     return `${emit(object)}[${emit(index)}]`;
@@ -187838,7 +187892,7 @@ class JinjaTopLevelEmitter {
       return "none";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, _optional, emit) {
     if (object.kind === "identifier" && object.name === "props") {
       return jinjaIdent(property);
     }
@@ -187850,7 +187904,7 @@ class JinjaTopLevelEmitter {
     const obj = emit(object);
     if (property === "length")
       return `bf.length(${obj})`;
-    return `${obj}.${property}`;
+    return `${obj}['${escapeJinjaSingleQuoted(property)}']`;
   }
   indexAccess(object, index, emit) {
     return `${emit(object)}[${emit(index)}]`;
@@ -188257,6 +188311,7 @@ class JinjaAdapter extends BaseAdapter {
   options;
   errors = [];
   inLoop = false;
+  currentLoopKeyDepth = 0;
   propsObjectName = null;
   propsParams = [];
   booleanTypedProps = new Set;
@@ -188265,6 +188320,7 @@ class JinjaAdapter extends BaseAdapter {
   _searchParamsLocals = new Set;
   _loweringMatchers = [];
   localConstants = [];
+  staticLoopSourceBoundNames = new Set;
   nullableOptionalProps = new Set;
   constructor(options = {}) {
     super();
@@ -188280,6 +188336,7 @@ class JinjaAdapter extends BaseAdapter {
     this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
     this.booleanTypedProps = collectBooleanTypedProps(ir);
     this.localConstants = ir.metadata.localConstants ?? [];
+    this.staticLoopSourceBoundNames = collectLoopBoundNames(ir);
     this.nullableOptionalProps = collectNullableOptionalProps(ir);
     this.stringValueNames = collectStringValueNames(ir);
     this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants);
@@ -188333,7 +188390,7 @@ class JinjaAdapter extends BaseAdapter {
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -188401,7 +188458,8 @@ class JinjaAdapter extends BaseAdapter {
   renderElement(element) {
     const tag = element.tag;
     const attrs = this.renderAttributes(element);
-    const children = this.renderChildren(element.children);
+    const dangerousHtml = this.renderDangerousInnerHtml(element);
+    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children);
     let hydrationAttrs = "";
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker("")}`;
@@ -188436,6 +188494,22 @@ class JinjaAdapter extends BaseAdapter {
     }
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
   }
+  renderDangerousInnerHtml(element) {
+    const resolution = resolveDangerousInnerHtml(element);
+    if (!resolution)
+      return null;
+    if (resolution.kind === "dynamic") {
+      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc));
+      return "";
+    }
+    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name);
+    if (violation) {
+      const attr = element.attrs.find(isDangerousInnerHtmlAttr);
+      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation));
+      return "";
+    }
+    return resolution.html;
+  }
   renderExpression(expr) {
     if (expr.clientOnly) {
       if (expr.slotId) {
@@ -188443,7 +188517,7 @@ class JinjaAdapter extends BaseAdapter {
       }
       return "";
     }
-    const jinjaExpr = `bf.string(${this.convertExpressionToJinja(expr.expr)})`;
+    const jinjaExpr = `bf.string(${this.convertExpressionToJinja(expr.expr, expr.parsed)})`;
     if (expr.slotId) {
       return `{{ bf.text_start("${expr.slotId}") | safe }}{{ ${jinjaExpr} }}{{ bf.text_end() | safe }}`;
     }
@@ -188535,8 +188609,12 @@ ${whenTrue}
         }
       });
     }
+    const staticItems = resolveStaticLoopSource(loop.arrayParsed, this.localConstants, {
+      isNameShadowed: (name) => this.staticLoopSourceBoundNames.has(name)
+    });
+    const staticArray = staticItems !== null ? staticValueToJinja(staticItems) : null;
     const arrayName = loop.array.trim();
-    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+    if (staticArray === null && /^[A-Za-z_$][\w$]*$/.test(arrayName)) {
       const arrayConst = (this.localConstants ?? []).find((c) => c.name === arrayName);
       if (arrayConst && !arrayConst.isModule && this._resolveLiteralConst(arrayName) === null) {
         this.errors.push({
@@ -188550,7 +188628,7 @@ ${whenTrue}
         });
       }
     }
-    const rawArray = this.convertExpressionToJinja(loop.array);
+    const rawArray = staticArray ?? this.convertExpressionToJinja(loop.array);
     let array = rawArray;
     if (loop.sortComparator) {
       const sort = loop.sortComparator;
@@ -188564,7 +188642,7 @@ ${whenTrue}
     const renderedChildren = this.renderChildren(loop.children);
     const loopVar = loop.iterationShape === "keys" ? "__bf_item" : supportableDestructure ? "__bf_item" : param;
     const indexLocalLines = [];
-    if (loop.iterationShape === "keys") {
+    if (loop.objectIteration) {} else if (loop.iterationShape === "keys") {
       indexLocalLines.push(`{% set ${jinjaIdent(param)} = loop.index0 %}`);
     } else if (loop.index) {
       indexLocalLines.push(`{% set ${jinjaIdent(loop.index)} = loop.index0 %}`);
@@ -188584,13 +188662,17 @@ ${whenTrue}
     }
     const prevInLoop = this.inLoop;
     this.inLoop = true;
+    const prevLoopKeyDepth = this.currentLoopKeyDepth;
+    this.currentLoopKeyDepth = loop.depth;
     const childrenUnderLoop = this.renderChildren(loop.children);
+    this.currentLoopKeyDepth = prevLoopKeyDepth;
     this.inLoop = prevInLoop;
     const bodyChildren = loop.bodyIsItemConditional && loop.key ? `{{ bf.comment("loop-i:" ~ bf.string(${this.convertExpressionToJinja(loop.key)})) | safe }}
 ${childrenUnderLoop}` : childrenUnderLoop;
     const lines = [];
     lines.push(`{{ bf.comment("loop:${loop.markerId}") | safe }}`);
-    lines.push(`{% for ${jinjaIdent(loopVar)} in ${array} %}`);
+    const forHeader = loop.objectIteration === "entries" ? `{% for ${jinjaIdent(loop.index ?? param)}, ${jinjaIdent(param)} in ${array}.items() %}` : loop.objectIteration === "keys" ? `{% for ${jinjaIdent(param)} in ${array}.keys() %}` : loop.objectIteration === "values" ? `{% for ${jinjaIdent(param)} in ${array}.values() %}` : `{% for ${jinjaIdent(loopVar)} in ${array} %}`;
+    lines.push(forHeader);
     for (const il of indexLocalLines)
       lines.push(il);
     if (loop.filterPredicate) {
@@ -188662,9 +188744,20 @@ ${childrenUnderLoop}` : childrenUnderLoop;
   renderComponent(comp) {
     const segments = [{ kind: "entries", parts: [] }];
     const currentEntries = () => this.componentPropSegmentEntries(segments);
+    const namedSlotSetBlocks = [];
     for (const p of comp.props) {
       if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
         continue;
+      if (p.value.kind === "jsx-children" && p.name !== "children") {
+        const prevInLoop = this.inLoop;
+        this.inLoop = false;
+        const slotBody = this.renderChildren(p.value.children);
+        this.inLoop = prevInLoop;
+        const captureName = `bf_prop_${this.childrenCaptureCounter++}`;
+        namedSlotSetBlocks.push(`{% set ${captureName} %}${slotBody}{% endset %}`);
+        currentEntries().push(`${jinjaHashKey(p.name)}: ${captureName}`);
+        continue;
+      }
       if (p.value.kind === "spread") {
         const trimmed = p.value.expr.trim();
         if (this.propsObjectName && this.propsObjectName === trimmed) {
@@ -188693,11 +188786,11 @@ ${childrenUnderLoop}` : childrenUnderLoop;
       const captureName = `bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
       currentEntries().push(`${jinjaHashKey("children")}: ${captureName}`);
       const dict = this.combineComponentPropSegments(segments);
-      return `{% set ${captureName} %}${childrenBody}{% endset %}{{ bf.render_child('${tplName}', ${dict}) | safe }}`;
+      return `${namedSlotSetBlocks.join("")}{% set ${captureName} %}${childrenBody}{% endset %}{{ bf.render_child('${tplName}', ${dict}) | safe }}`;
     }
     const isEmpty = segments.every((s) => s.kind === "entries" && s.parts.length === 0);
     const dictEntries = isEmpty ? "" : `, ${this.combineComponentPropSegments(segments)}`;
-    return `{{ bf.render_child('${tplName}'${dictEntries}) | safe }}`;
+    return `${namedSlotSetBlocks.join("")}{{ bf.render_child('${tplName}'${dictEntries}) | safe }}`;
   }
   childrenCaptureCounter = 0;
   presenceVarCounter = 0;
@@ -188742,7 +188835,7 @@ ${alternate}
 ${children}`;
   }
   elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       if (name === "style") {
         const css = this.tryLowerStyleObject(value.expr);
@@ -188847,12 +188940,15 @@ ${name}="{{ bf.string(${val}) }}"
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       let attrName;
       if (attr.name === "className")
         attrName = "class";
-      else if (attr.name === "key")
-        attrName = "data-key";
-      else
+      else if (attr.name === "key") {
+        const depth = this.currentLoopKeyDepth;
+        attrName = depth > 0 ? `data-key-${depth}` : "data-key";
+      } else
         attrName = attr.name;
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
       if (lowered)
@@ -189045,6 +189141,8 @@ Options:
     return isBooleanResultExpr(expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(expr);
   }
   _resolveLiteralConst(name) {
+    if (this.staticLoopSourceBoundNames.has(name))
+      return null;
     const c = (this.localConstants ?? []).find((lc) => lc.name === name);
     if (c?.value === undefined)
       return null;
@@ -189057,6 +189155,8 @@ Options:
     return null;
   }
   _resolveStaticRecordLiteral(objectName, key) {
+    if (this.staticLoopSourceBoundNames.has(objectName))
+      return null;
     const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants);
     if (!hit)
       return null;
@@ -189094,14 +189194,10 @@ Options:
 var jinjaAdapter = new JinjaAdapter;
 // src/conformance-pins.ts
 var conformancePins = {
-  "static-array-children": [{ code: "BF103", severity: "error" }],
-  "todo-app": [{ code: "BF103", severity: "error" }],
-  "todo-app-ssr": [{ code: "BF103", severity: "error" }],
   "static-array-from-props": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2087" }
   ],
   "static-array-from-props-with-component": [
-    { code: "BF103", severity: "error" },
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2087" }
   ],
   "filter-nested-callback-predicate": [
@@ -189110,21 +189206,10 @@ var conformancePins = {
   "filter-nested-find-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
-  "array-map-function-reference": [{ code: "BF101", severity: "error" }],
-  "dangerous-inner-html": [{ code: "BF101", severity: "error" }],
-  "string-replaceall": [{ code: "BF101", severity: "error" }]
+  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "html-entity-text": "`&copy;` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes",
-  "math-methods": "Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)",
-  "static-attr-escape": 'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  "object-entries-map": "`Object.entries(prop).map(([k, v]) => …)` renders an EMPTY list — the object-shaped prop silently produces zero iterations",
-  "nested-loop-outer-binding": "nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`",
-  "jsx-element-prop": "a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped",
-  "string-slice": "`.slice()` on a STRING renders empty (array-slice helper misfires on strings)",
-  "string-trim-sided": "`.trimStart()` / `.trimEnd()` render empty (no lowering)"
-};
+var renderDivergences = {};
 export {
   renderDivergences,
   jinjaAdapter,

package/dist/render-divergences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAiB/B,CAAA"}
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAK/B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jinja",
-  "version": "0.18.4",
+  "version": "0.18.7",
   "description": "Jinja2 adapter for BarefootJS — compiles IR to .jinja templates and ships the Python BarefootJS rendering runtime; runs under any Python web framework (Flask, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,14 +53,14 @@
     "directory": "packages/adapter-jinja"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.18.4"
+    "@barefootjs/shared": "0.18.7"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.18.4",
+    "@barefootjs/jsx": "0.18.7",
     "typescript": "^5.0.0"
   }
 }

package/python/barefootjs/runtime.py

@@ -819,6 +819,29 @@ class BarefootJS:
         # is -1, not -2). `floor(n + 0.5)` reproduces that for both signs.
         return float(math.floor(n + 0.5))
 
+    def min(self, a: Any, b: Any) -> float:
+        """`Math.min(a, b)` -- two-arg form only (#2168 math-methods).
+        JS returns NaN if either operand is NaN."""
+        x, y = js_number(a), js_number(b)
+        if _is_nan(x):
+            return x
+        if _is_nan(y):
+            return y
+        return x if x < y else y
+
+    def max(self, a: Any, b: Any) -> float:
+        x, y = js_number(a), js_number(b)
+        if _is_nan(x):
+            return x
+        if _is_nan(y):
+            return y
+        return x if x > y else y
+
+    def abs(self, value: Any) -> float:
+        """`Math.abs()` (#2168 math-methods)."""
+        n = js_number(value)
+        return n if _is_nan(n) else abs(n)
+
     # -----------------------------------------------------------------
     # Array / String method helpers (#1448 Tier A)
     # -----------------------------------------------------------------
@@ -933,12 +956,20 @@ class BarefootJS:
             out.extend(b)
         return out
 
-    def slice(self, recv: Any, start: Any, end: Any) -> list:
-        if not isinstance(recv, list):
+    def slice(self, recv: Any, start: Any, end: Any) -> Any:
+        # `Array.prototype.slice(start, end?)` AND `String.prototype.slice`
+        # (the `string-slice` divergence, #2182) -- the adapter emits the
+        # same `bf.slice(recv, start, end)` call for both receiver shapes
+        # (it can't disambiguate string vs. array at compile time), so
+        # this dispatches on the Python type, mirroring `includes` above.
+        # `str` and `list` share slicing semantics (`recv[s:e]`) and
+        # `len()`, so one clamp computation serves both; `str` indexing
+        # is by Unicode code point already, matching JS except for
+        # astral-plane input (the same divergence boundary every other
+        # adapter's pad/trim helpers already accept).
+        if not isinstance(recv, (list, str)):
             return []
         length = len(recv)
-        if length == 0:
-            return []
         s = start if start is not None else 0
         if s < 0:
             s = length + s
@@ -950,8 +981,8 @@ class BarefootJS:
         e = max(e, 0)
         e = min(e, length)
         if s >= e:
-            return []
-        return list(recv[s:e])
+            return recv[0:0]
+        return recv[s:e] if isinstance(recv, str) else list(recv[s:e])
 
     def reverse(self, recv: Any) -> list:
         if not isinstance(recv, list):
@@ -1014,6 +1045,20 @@ class BarefootJS:
             return ""
         return js_string(recv).strip()
 
+    def trim_start(self, recv: Any) -> str:
+        """`String.prototype.trimStart()` -- the one-sided sibling of `trim`
+        above (#2183 follow-up)."""
+        if recv is None or isinstance(recv, (list, dict)):
+            return ""
+        return js_string(recv).lstrip()
+
+    def trim_end(self, recv: Any) -> str:
+        """`String.prototype.trimEnd()` -- the one-sided sibling of `trim`
+        above (#2183 follow-up)."""
+        if recv is None or isinstance(recv, (list, dict)):
+            return ""
+        return js_string(recv).rstrip()
+
     def to_fixed(self, value: Any, digits: int = 0) -> str:
         n = self.number(value)
         if _is_nan(n):
@@ -1076,6 +1121,19 @@ class BarefootJS:
             return s
         return s[:i] + n + s[i + len(o) :]
 
+    def replace_all(self, recv: Any, pattern: Any, replacement: Any) -> str:
+        """`String.prototype.replaceAll(pattern, replacement)`, string-pattern
+        form only (#2182) -- every occurrence, the all-occurrences sibling of
+        `replace` above. Python's own `str.replace(old, new)` (no count arg)
+        is already global by default, including the empty-pattern-inserts-
+        at-every-boundary edge case (`"abc".replace("", "X")` -> "XaXbXcX"),
+        so it needs no hand-rolled loop the way the other runtimes' first-
+        occurrence-only native replace does."""
+        s = _scalar_or_empty(recv)
+        o = js_string(pattern)
+        n = js_string(replacement)
+        return s.replace(o, n)
+
     def query(self, base: Any, *triples: Any) -> str:
         """`queryHref(base, {...})` (#2042) -- build `"$base?k=v&..."` from a
         flat list of (guard, key, value) triples. A pair is included iff its

package/python/tests/test_helper_vectors.py

@@ -117,13 +117,19 @@ BINDINGS = {
     "floor": bf.floor,
     "ceil": bf.ceil,
     "round": bf.round,
+    "min": bf.min,
+    "max": bf.max,
+    "abs": bf.abs,
     "to_fixed": lambda *a: bf.to_fixed(*a),
     "lower": bf.lc,
     "upper": bf.uc,
     "trim": bf.trim,
+    "trim_start": bf.trim_start,
+    "trim_end": bf.trim_end,
     "starts_with": lambda *a: bf.starts_with(*a),
     "ends_with": lambda *a: bf.ends_with(*a),
     "replace": lambda *a: bf.replace(*a),
+    "replace_all": lambda *a: bf.replace_all(*a),
     "repeat": lambda *a: bf.repeat(*a),
     "pad_start": lambda *a: bf.pad_start(*a),
     "pad_end": lambda *a: bf.pad_end(*a),

package/python/tests/test_template_primitives.py

@@ -74,6 +74,27 @@ class TemplatePrimitivesTest(unittest.TestCase):
         self.assertEqual(self.bf.round(-1.6), -2)
         self.assertTrue(_is_nan(self.bf.round("not")))
 
+    def test_min_max_abs(self):
+        # `Math.min(a, b)` / `Math.max(a, b)` (two-arg forms only) and
+        # `Math.abs()` (#2168 math-methods). JS returns NaN if EITHER
+        # min/max operand is NaN.
+        self.assertEqual(self.bf.min(3, 7), 3)
+        self.assertEqual(self.bf.min(7, 3), 3)
+        self.assertEqual(self.bf.min(-2, -5), -5)
+        self.assertTrue(_is_nan(self.bf.min("not", 5)))
+        self.assertTrue(_is_nan(self.bf.min(5, "not")))
+
+        self.assertEqual(self.bf.max(3, 7), 7)
+        self.assertEqual(self.bf.max(7, 3), 7)
+        self.assertEqual(self.bf.max(-2, -5), -2)
+        self.assertTrue(_is_nan(self.bf.max("not", 5)))
+        self.assertTrue(_is_nan(self.bf.max(5, "not")))
+
+        self.assertEqual(self.bf.abs(-7.6), 7.6)
+        self.assertEqual(self.bf.abs(7.6), 7.6)
+        self.assertEqual(self.bf.abs(0), 0)
+        self.assertTrue(_is_nan(self.bf.abs("not")))
+
     def test_includes_dispatch(self):
         # `Array.prototype.includes(x)` + `String.prototype.includes(sub)`
         # lower to the same `bf.includes(recv, elem)` shape -- see #1448
@@ -158,6 +179,18 @@ class TemplatePrimitivesTest(unittest.TestCase):
         out.append("mutated")
         self.assertEqual(src, ["a", "b", "c"])
 
+    def test_slice_string_receiver(self):
+        # The `string-slice` divergence (#2182): a string receiver used
+        # to fall through the array-only branch and return an empty
+        # list instead of a substring.
+        word = "barefootjs"
+        self.assertEqual(self.bf.slice(word, 0, 4), "bare")
+        self.assertEqual(self.bf.slice(word, -4, None), "otjs")
+        self.assertEqual(self.bf.slice(word, 4, None), "footjs")
+        self.assertEqual(self.bf.slice(word, 5, 2), "")
+        # Multi-byte: index by character, not byte.
+        self.assertEqual(self.bf.slice("héllo", 0, 2), "hé")
+
     def test_reverse_mutation_isolation(self):
         self.assertEqual(self.bf.reverse(["a", "b", "c"]), ["c", "b", "a"])
         self.assertEqual(self.bf.reverse([]), [])
@@ -175,6 +208,18 @@ class TemplatePrimitivesTest(unittest.TestCase):
         self.assertEqual(self.bf.trim({"a": 1}), "")
         self.assertEqual(self.bf.trim(42), "42")
 
+    def test_trim_start_and_trim_end(self):
+        # The one-sided siblings of `trim` above (#2183). Padding BOTH
+        # sides so a swapped side fails visibly.
+        self.assertEqual(self.bf.trim_start("   padded   "), "padded   ")
+        self.assertEqual(self.bf.trim_end("   padded   "), "   padded")
+        self.assertEqual(self.bf.trim_start(""), "")
+        self.assertEqual(self.bf.trim_end(""), "")
+        self.assertEqual(self.bf.trim_start(None), "")
+        self.assertEqual(self.bf.trim_end(None), "")
+        self.assertEqual(self.bf.trim_start({"a": 1}), "")
+        self.assertEqual(self.bf.trim_end([1, 2]), "")
+
     def test_split(self):
         self.assertEqual(self.bf.split("a,b,c", ","), ["a", "b", "c"])
         self.assertEqual(self.bf.split("a.b.c", "."), ["a", "b", "c"])