jprx 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 - 2026 Simon Y. Blackwell, AnyWhichWay LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# JPRX (JSON Reactive Path eXpressions)
+
+**JPRX** is a declarative, reactive expression syntax designed for JSON-based data structures. It extends [JSON Pointer (RFC 6901)](https://www.rfc-editor.org/rfc/rfc6901) with reactivity, relative paths, operator syntax, and a rich library of helper functions.
+
+## Overview
+
+JPRX is a **syntax** and an **expression engine**. While this repository provides the parser and core helper functions, JPRX is intended to be integrated into UI libraries or state management systems that can "hydrate" these expressions into active reactive bindings.
+
+### Why JPRX?
+
+- **Declarative Power**: Define relationships between data points as easily as writing an Excel formula.
+- **Security**: JPRX strictly avoids `eval()`. Expressions are handled by a custom high-performance Pratt parser and a registry of pre-defined helpers, making it safe for dynamic content.
+- **Portability**: Because JPRX expressions are strings within JSON structures, they are easily serialized, stored, and sent over the wire.
+- **Platform Agnostic**: While Lightview is the first implementation, JPRX can be used in any environment that manages reactive state.
+
+## Syntax & Features
+
+JPRX extends the base JSON Pointer syntax with:
+
+| Feature | Syntax | Description |
+|---------|--------|-------------|
+| **Global Path** | `$/user/name` | Access global state via an absolute path. |
+| **Relative Path** | `./count` | Access properties relative to the current context. |
+| **Parent Path** | `../id` | Traverse up the state hierarchy. |
+| **Functions** | `$sum(/items...price)` | Call registered core helpers. |
+| **Explosion** | `/items...name` | Extract a property from every object in an array (spread). |
+| **Operators** | `$++/count`, `$/a + $/b` | Familiar JS-style prefix, postfix, and infix operators. |
+| **Placeholders** | `_` (item), `$event` | Context-aware placeholders for iteration and interaction. |
+
+## Human & AI Utility
+
+JPRX is uniquely positioned to bridge the gap between human developers and AI coding assistants:
+
+### For Humans: "The Excel Paradigm"
+Humans are often familiar with the "recalculation" model of spreadsheets. JPRX brings this to UI development. Instead of writing complex "glue code" (event listeners, state updates, DOM manipulation), developers specify the *formula* for a UI element once, and it stays updated forever.
+
+### For AI: Structured & Concise
+Large Language Models (LLMs) are exceptionally good at generating structured data (JSON) and formulaic expressions. They are often prone to errors when generating large blocks of imperative JavaScript logic. JPRX provides a high-level, declarative "target" for AI to aim at, resulting in:
+- **Higher Accuracy**: Less boilerplate means fewer places for the AI to hallucinate.
+- **Safety**: AI can generate UI logic that remains sandboxed and secure.
+- **Compactness**: Entire interactive components can be described in a few lines of JSON.
+
+## Operators
+
+JPRX supports a wide range of operators that provide a more concise and familiar syntax than function calls.
+
+### Arithmetic & Logic (Infix)
+Infix operators require surrounding whitespace in JPRX to avoid ambiguity with path separators.
+
+- **Arithmetic**: `+`, `-`, `*`, `/`, `mod`, `pow`
+- **Comparison**: `>`, `<`, `>=`, `<=`, `==`, `!=`
+- **Logic**: `&&`, `||`
+
+*Example:* `$/a + $/b * 10 > $/threshold`
+
+### Mutation & Unary (Prefix/Postfix)
+These operators are typically used in event handlers or for immediate state transformation.
+
+- **Increment**: `$++/count` (prefix) or `$/count++` (postfix)
+- **Decrement**: `$--/count` (prefix) or `$/count--` (postfix)
+- **Toggle**: `$!!/enabled` (logical NOT/toggle)
+
+## Helper Functions
+
+JPRX includes a comprehensive library of built-in helpers. For security, only registered helpers are available—there is no access to the global JavaScript environment.
+
+### Math
+`add`, `sub`, `mul`, `div`, `mod`, `pow`, `sqrt`, `abs`, `round`, `ceil`, `floor`, `min`, `max`
+
+### Stats
+`sum`, `avg`, `min`, `max`, `median`, `stdev`, `var`
+
+### String
+`upper`, `lower`, `trim`, `capitalize`, `titleCase`, `contains`, `startsWith`, `endsWith`, `replace`, `split`, `join`, `concat`, `len`, `default`
+
+### Array
+`count`, `map`, `filter`, `find`, `unique`, `sort`, `reverse`, `first`, `last`, `slice`, `flatten`, `join`, `len`
+
+### Logic & Comparison
+`if`, `and`, `or`, `not`, `eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `between`, `in`
+
+### Formatting
+`number`, `currency`, `percent`, `thousands`
+
+### DateTime
+`now`, `today`, `date`, `formatDate`, `year`, `month`, `day`, `weekday`, `addDays`, `dateDiff`
+
+### Lookup
+`lookup`, `vlookup`, `index`, `match`
+
+### State Mutation
+`set`, `increment`, `decrement`, `toggle`, `push`, `pop`, `assign`, `clear`
+
+### Network
+`fetch(url, options?)` - *Auto-serializes JSON bodies and handles content-types.*
+
+## Example
+
+A simple reactive counter described in JPRX syntax:
+
+```json
+{
+  "div": {
+    "cdom-state": { "count": 0 },
+    "children": [
+      { "h2": "Counter" },
+      { "p": ["Current Count: ", "$/count"] },
+      { "button": { "onclick": "$increment(/count)", "children": ["+"] } },
+      { "button": { "onclick": "$decrement(/count)", "children": ["-"] } }
+    ]
+  }
+}
+```
+
+## Reference Implementation: Lightview
+
+JPRX was originally developed for [Lightview](https://github.com/anywhichway/lightview) to power its **Computational DOM (cDOM)**. Lightview serves as the primary example of how a UI library can hydrate JPRX expressions into a live, reactive interface.
+
+If you are building a UI library and want to support reactive JSON structures, this parser provides the foundation.
+
+## Getting Started
+
+The JPRX package contains:
+1. `parser.js`: The core Pratt parser and path resolution logic.
+2. `helpers/`: A comprehensive library of math, logic, string, array, formatting, and state helpers.
+
+To use JPRX, you typically register your state-management primitives (like Signals or Proxies) with the parser's registry, and then call `hydrate()` or `resolveExpression()` to activate the logic.
+
+---
+© 2026 Simon Y. Blackwell, AnyWhichWay LLC. Licensed under MIT.

package/helpers/array.js

@@ -0,0 +1,75 @@
+/**
+ * cdom ARRAY HELPERS
+ */
+
+export const count = (...args) => args.length;
+
+export const filter = (arr, predicate) => {
+    if (!Array.isArray(arr)) return [];
+    if (typeof predicate === 'function' && predicate.isLazy) {
+        return arr.filter(item => predicate.resolve(item));
+    }
+    return arr.filter(item => !!item);
+};
+
+export const map = (arr, transform) => {
+    if (!Array.isArray(arr)) return [];
+    if (typeof transform === 'string') {
+        return arr.map(item => (item && typeof item === 'object') ? item[transform] : item);
+    }
+    // Check for LazyValue (has isLazy property and resolve method)
+    if (transform && transform.isLazy && typeof transform.resolve === 'function') {
+        return arr.map(item => transform.resolve(item));
+    }
+    // If it's a plain function
+    if (typeof transform === 'function') {
+        return arr.map(transform);
+    }
+    return arr;
+};
+
+export const find = (arr, predicate) => {
+    if (!Array.isArray(arr)) return undefined;
+    if (predicate && predicate.isLazy) {
+        return arr.find(item => predicate.resolve(item));
+    }
+    return arr.find(item => !!item);
+};
+
+export const unique = (arr) => Array.isArray(arr) ? [...new Set(arr)] : [];
+
+export const sort = (arr, order = 'asc') => {
+    if (!Array.isArray(arr)) return [];
+    const sorted = [...arr];
+    sorted.sort((a, b) => {
+        if (a < b) return order === 'asc' ? -1 : 1;
+        if (a > b) return order === 'asc' ? 1 : -1;
+        return 0;
+    });
+    return sorted;
+};
+
+export const reverse = (arr) => Array.isArray(arr) ? [...arr].reverse() : [];
+export const first = (arr) => Array.isArray(arr) ? arr[0] : undefined;
+export const last = (arr) => Array.isArray(arr) ? arr[arr.length - 1] : undefined;
+export const slice = (arr, start, end) => Array.isArray(arr) ? arr.slice(start, end) : [];
+export const flatten = (arr) => Array.isArray(arr) ? arr.flat(Infinity) : [];
+export const join = (arr, sep = ',') => Array.isArray(arr) ? arr.join(String(sep)) : '';
+export const length = (arg) => Array.isArray(arg) ? arg.length : (arg ? String(arg).length : 0);
+
+export const registerArrayHelpers = (register) => {
+    register('count', count);
+    register('filter', filter, { lazyAware: true });
+    register('map', map, { lazyAware: true });
+    register('find', find, { lazyAware: true });
+    register('unique', unique);
+    register('sort', sort);
+    register('reverse', reverse);
+    register('first', first);
+    register('last', last);
+    register('slice', slice);
+    register('flatten', flatten);
+    register('join', join);
+    register('len', length);
+    register('length', length);
+};

package/helpers/compare.js

@@ -0,0 +1,26 @@
+/**
+ * cdom COMPARISON HELPERS
+ */
+
+export const gt = (a, b) => a > b;
+export const lt = (a, b) => a < b;
+export const gte = (a, b) => a >= b;
+export const lte = (a, b) => a <= b;
+export const neq = (a, b) => a !== b;
+export const between = (val, min, max) => val >= min && val <= max;
+export const contains = (arr, val) => Array.isArray(arr) && arr.includes(val);
+
+export const registerCompareHelpers = (register) => {
+    register('gt', gt);
+    register('>', gt);
+    register('lt', lt);
+    register('<', lt);
+    register('gte', gte);
+    register('>=', gte);
+    register('lte', lte);
+    register('<=', lte);
+    register('neq', neq);
+    register('!=', neq);
+    register('between', between);
+    register('in', contains);
+};

package/helpers/conditional.js

@@ -0,0 +1,34 @@
+/**
+ * cdom CONDITIONAL AGGREGATE HELPERS
+ */
+
+export const sumIf = (arr, predicate) => {
+    if (!Array.isArray(arr)) return 0;
+    const filtered = (predicate && predicate.isLazy)
+        ? arr.filter(item => predicate.resolve(item))
+        : arr;
+    return filtered.reduce((a, b) => a + (Number(b) || 0), 0);
+};
+
+export const countIf = (arr, predicate) => {
+    if (!Array.isArray(arr)) return 0;
+    if (predicate && predicate.isLazy) {
+        return arr.filter(item => predicate.resolve(item)).length;
+    }
+    return arr.filter(item => !!item).length;
+};
+
+export const avgIf = (arr, predicate) => {
+    if (!Array.isArray(arr)) return 0;
+    const filtered = (predicate && predicate.isLazy)
+        ? arr.filter(item => predicate.resolve(item))
+        : arr;
+    if (filtered.length === 0) return 0;
+    return filtered.reduce((a, b) => a + (Number(b) || 0), 0) / filtered.length;
+};
+
+export const registerConditionalHelpers = (register) => {
+    register('sumIf', sumIf);
+    register('countIf', countIf);
+    register('avgIf', avgIf);
+};

package/helpers/datetime.js

@@ -0,0 +1,54 @@
+/**
+ * cdom DATE/TIME HELPERS
+ */
+
+export const now = () => new Date().getTime();
+export const today = () => {
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+};
+
+export const date = (val) => new Date(val).getTime();
+
+export const formatDate = (val, format) => {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return '';
+
+    // Minimal formatter, can be expanded
+    const options = { year: 'numeric', month: '2-digit', day: '2-digit' };
+    if (format === 'long') options.month = 'long';
+    return d.toLocaleDateString(undefined, options);
+};
+
+export const year = (val) => new Date(val).getFullYear();
+export const month = (val) => new Date(val).getMonth() + 1;
+export const day = (val) => new Date(val).getDate();
+export const weekday = (val) => new Date(val).getDay();
+
+export const addDays = (val, days) => {
+    const d = new Date(val);
+    d.setDate(d.getDate() + Number(days));
+    return d.getTime();
+};
+
+export const dateDiff = (d1, d2, unit = 'days') => {
+    const diff = Math.abs(new Date(d1) - new Date(d2));
+    if (unit === 'seconds') return diff / 1000;
+    if (unit === 'minutes') return diff / (1000 * 60);
+    if (unit === 'hours') return diff / (1000 * 60 * 60);
+    return diff / (1000 * 60 * 60 * 24);
+};
+
+export const registerDateTimeHelpers = (register) => {
+    register('now', now);
+    register('today', today);
+    register('date', date);
+    register('formatDate', formatDate);
+    register('year', year);
+    register('month', month);
+    register('day', day);
+    register('weekday', weekday);
+    register('addDays', addDays);
+    register('dateDiff', dateDiff);
+};

package/helpers/format.js

@@ -0,0 +1,20 @@
+/**
+ * cdom FORMATTING HELPERS
+ */
+
+export const number = (val, decimals = 2) => Number(val).toFixed(decimals);
+
+export const currency = (val, symbol = '$', decimals = 2) => {
+    return symbol + Number(val).toFixed(decimals).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+
+export const percent = (val, decimals = 0) => (Number(val) * 100).toFixed(decimals) + '%';
+
+export const thousands = (val) => String(val).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+
+export const registerFormatHelpers = (register) => {
+    register('number', number);
+    register('currency', currency);
+    register('percent', percent);
+    register('thousands', thousands);
+};

package/helpers/logic.js

@@ -0,0 +1,24 @@
+/**
+ * cdom LOGIC HELPERS
+ */
+
+export const ifHelper = (condition, thenVal, elseVal) => condition ? thenVal : elseVal;
+export const andHelper = (...args) => args.every(Boolean);
+export const orHelper = (...args) => args.some(Boolean);
+export const notHelper = (val) => !val;
+export const eqHelper = (a, b) => a === b;
+export const neqHelper = (a, b) => a !== b;
+
+export const registerLogicHelpers = (register) => {
+    register('if', ifHelper);
+    register('and', andHelper);
+    register('&&', andHelper);
+    register('or', orHelper);
+    register('||', orHelper);
+    register('not', notHelper);
+    register('!', notHelper);
+    register('eq', eqHelper);
+    register('==', eqHelper);
+    register('===', eqHelper);
+    register('neq', neqHelper);
+};

package/helpers/lookup.js

@@ -0,0 +1,25 @@
+/**
+ * cdom LOOKUP HELPERS
+ */
+
+export const lookup = (val, searchArr, resultArr) => {
+    if (!Array.isArray(searchArr)) return undefined;
+    const idx = searchArr.indexOf(val);
+    return idx !== -1 && Array.isArray(resultArr) ? resultArr[idx] : undefined;
+};
+
+export const vlookup = (val, table, colIdx) => {
+    if (!Array.isArray(table)) return undefined;
+    const row = table.find(r => Array.isArray(r) && r[0] === val);
+    return row ? row[colIdx - 1] : undefined;
+};
+
+export const index = (arr, idx) => Array.isArray(arr) ? arr[idx] : undefined;
+export const match = (val, arr) => Array.isArray(arr) ? arr.indexOf(val) : -1;
+
+export const registerLookupHelpers = (register) => {
+    register('lookup', lookup);
+    register('vlookup', vlookup);
+    register('index', index);
+    register('match', match);
+};

package/helpers/math.js

@@ -0,0 +1,34 @@
+/**
+ * cdom MATH HELPERS
+ */
+
+export const add = (...args) => args.reduce((a, b) => Number(a) + Number(b), 0);
+export const subtract = (a, b) => Number(a) - Number(b);
+export const multiply = (...args) => args.reduce((a, b) => Number(a) * Number(b), 1);
+export const divide = (a, b) => Number(a) / Number(b);
+
+export const round = (val, decimals = 0) => Number(Math.round(val + 'e' + decimals) + 'e-' + decimals);
+export const ceil = (val) => Math.ceil(val);
+export const floor = (val) => Math.floor(val);
+export const abs = (val) => Math.abs(val);
+export const mod = (a, b) => a % b;
+export const pow = (a, b) => Math.pow(a, b);
+export const sqrt = (val) => Math.sqrt(val);
+
+export const registerMathHelpers = (register) => {
+    register('+', add);
+    register('add', add);
+    register('-', subtract);
+    register('sub', subtract);
+    register('*', multiply);
+    register('mul', multiply);
+    register('/', divide);
+    register('div', divide);
+    register('round', round);
+    register('ceil', ceil);
+    register('floor', floor);
+    register('abs', abs);
+    register('mod', mod);
+    register('pow', pow);
+    register('sqrt', sqrt);
+};

package/helpers/network.js

@@ -0,0 +1,41 @@
+/**
+ * cdom NETWORK HELPERS
+ */
+
+/**
+ * A wrapper around the native fetch API that handles body serialization and 
+ * Content-Type headers based on the body type.
+ * 
+ * @param {string} url - The URL to fetch
+ * @param {object} options - Fetch options (method, headers, body)
+ */
+export const fetchHelper = (url, options = {}) => {
+    const fetchOptions = { ...options };
+    const headers = { ...fetchOptions.headers };
+
+    let body = fetchOptions.body;
+    if (body !== undefined) {
+        if (body !== null && typeof body === 'object') {
+            // Automatically stringify objects
+            body = JSON.stringify(body);
+            if (!headers['Content-Type']) {
+                headers['Content-Type'] = 'application/json';
+            }
+        } else {
+            // Convert everything else to string
+            body = String(body);
+            if (!headers['Content-Type']) {
+                headers['Content-Type'] = 'text/plain';
+            }
+        }
+    }
+
+    fetchOptions.body = body;
+    fetchOptions.headers = headers;
+
+    return globalThis.fetch(url, fetchOptions);
+};
+
+export const registerNetworkHelpers = (register) => {
+    register('fetch', fetchHelper);
+};

package/helpers/state.js

@@ -0,0 +1,80 @@
+/**
+ * cdom STATE/MUTATION HELPERS
+ */
+
+export const set = (target, val) => {
+    if (target && typeof target === 'object' && 'value' in target) {
+        target.value = val;
+    } else if (target && typeof target === 'function' && 'value' in target) {
+        target.value = val;
+    } else if (target && typeof target === 'object' && val && typeof val === 'object') {
+        Object.assign(target, val);
+    }
+    return val;
+};
+
+export const increment = (target, by = 1) => {
+    const hasValue = target && (typeof target === 'object' || typeof target === 'function') && 'value' in target;
+    const current = hasValue ? target.value : 0;
+    const next = Number(current) + Number(by);
+    return set(target, next);
+};
+
+export const decrement = (target, by = 1) => {
+    const hasValue = target && (typeof target === 'object' || typeof target === 'function') && 'value' in target;
+    const current = hasValue ? target.value : 0;
+    const next = Number(current) - Number(by);
+    return set(target, next);
+};
+
+export const toggle = (target) => {
+    const hasValue = target && (typeof target === 'object' || typeof target === 'function') && 'value' in target;
+    const current = hasValue ? target.value : false;
+    return set(target, !current);
+};
+
+export const push = (target, item) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : [];
+    if (Array.isArray(current)) {
+        const next = [...current, item];
+        return set(target, next);
+    }
+    return current;
+};
+
+export const pop = (target) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : [];
+    if (Array.isArray(current) && current.length > 0) {
+        const next = current.slice(0, -1);
+        set(target, next);
+    }
+    return current;
+};
+
+export const assign = (target, obj) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : {};
+    const next = { ...current, ...obj };
+    return set(target, next);
+};
+
+export const clear = (target) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : null;
+    if (Array.isArray(current)) return set(target, []);
+    if (typeof current === 'object' && current !== null) return set(target, {});
+    return set(target, null);
+};
+
+export const registerStateHelpers = (register) => {
+    const opts = { pathAware: true };
+    register('set', set, opts);
+    register('increment', increment, opts);
+    register('++', increment, opts);
+    register('decrement', decrement, opts);
+    register('--', decrement, opts);
+    register('toggle', toggle, opts);
+    register('!!', toggle, opts);
+    register('push', push, opts);
+    register('pop', pop, opts);
+    register('assign', assign, opts);
+    register('clear', clear, opts);
+};

package/helpers/stats.js

@@ -0,0 +1,39 @@
+/**
+ * cdom STATISTICAL HELPERS
+ */
+
+export const sum = (...args) => args.reduce((a, b) => a + (Number(b) || 0), 0);
+export const avg = (...args) => args.length === 0 ? 0 : sum(...args) / args.length;
+export const min = (...args) => Math.min(...args);
+export const max = (...args) => Math.max(...args);
+
+export const median = (...args) => {
+    if (args.length === 0) return 0;
+    const sorted = [...args].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+};
+
+export const stdev = (...args) => {
+    if (args.length === 0) return 0;
+    const mean = avg(...args);
+    const squareDiffs = args.map(value => Math.pow(value - mean, 2));
+    return Math.sqrt(avg(...squareDiffs));
+};
+
+export const variance = (...args) => {
+    if (args.length === 0) return 0;
+    const mean = avg(...args);
+    const squareDiffs = args.map(value => Math.pow(value - mean, 2));
+    return avg(...squareDiffs);
+};
+
+export const registerStatsHelpers = (register) => {
+    register('sum', sum);
+    register('avg', avg);
+    register('min', min);
+    register('max', max);
+    register('median', median);
+    register('stdev', stdev);
+    register('var', variance);
+};

package/helpers/string.js

@@ -0,0 +1,49 @@
+/**
+ * cdom STRING HELPERS
+ */
+
+export const join = (...args) => {
+    const separator = args[args.length - 1];
+    const items = args.slice(0, -1);
+    return items.join(separator);
+};
+
+export const concat = (...args) => args.join('');
+export const upper = (s) => String(s).toUpperCase();
+export const lower = (s) => String(s).toLowerCase();
+export const trim = (s) => String(s).trim();
+export const len = (s) => String(s).length;
+export const replace = (s, search, replacement) => String(s).replace(search, replacement);
+export const split = (s, separator) => String(s).split(separator);
+
+export const capitalize = (s) => {
+    const str = String(s);
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+export const titleCase = (s) => {
+    return String(s).toLowerCase().split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+};
+
+export const contains = (s, search) => String(s).includes(search);
+export const startsWith = (s, prefix) => String(s).startsWith(prefix);
+export const endsWith = (s, suffix) => String(s).endsWith(suffix);
+
+export const defaultHelper = (val, fallback) => (val !== undefined && val !== null) ? val : fallback;
+
+export const registerStringHelpers = (register) => {
+    register('join', join);
+    register('concat', concat);
+    register('upper', upper);
+    register('lower', lower);
+    register('trim', trim);
+    register('len', len);
+    register('replace', replace);
+    register('split', split);
+    register('capitalize', capitalize);
+    register('titleCase', titleCase);
+    register('contains', contains);
+    register('startsWith', startsWith);
+    register('endsWith', endsWith);
+    register('default', defaultHelper);
+};