littlewing 2.3.1 → 2.3.2

package/dist/index.d.ts

@@ -760,7 +760,7 @@ declare const defaultContext: ExecutionContext;
 * Note: PlainDateTime check must precede PlainDate because PlainDateTime is not an
 * instance of PlainDate in the Temporal API, but ordering is kept explicit for clarity.
 */
-declare function typeOf(value: RuntimeValue): string;
+declare function typeOf(value: unknown): string;
 /**
 * Assert a value is a number, throwing a TypeError if not
 */

package/dist/index.js

@@ -740,21 +740,25 @@ function lexIdentifier(cursor) {
 
 // src/utils.ts
 function typeOf(value) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null)
+    return "null";
   if (typeof value === "number")
     return "number";
   if (typeof value === "string")
     return "string";
   if (typeof value === "boolean")
     return "boolean";
+  if (Array.isArray(value))
+    return "array";
   if (value instanceof Temporal.PlainDateTime)
     return "datetime";
   if (value instanceof Temporal.PlainDate)
     return "date";
   if (value instanceof Temporal.PlainTime)
     return "time";
-  if (Array.isArray(value))
-    return "array";
-  throw new Error(`Unknown runtime value type`);
+  return typeof value;
 }
 function deepEquals(a, b) {
   if (typeof a === "number" && typeof b === "number")
@@ -791,6 +795,13 @@ function assertNumber(v, context, side) {
     throw new TypeError(`${context}${where} expected number, got ${typeOf(v)}`);
   }
 }
+function assertInteger(v, context, side) {
+  assertNumber(v, context, side);
+  if (!Number.isInteger(v)) {
+    const where = side ? ` (${side})` : "";
+    throw new TypeError(`${context}${where} expected integer, got ${v}`);
+  }
+}
 function assertBoolean(v, context, side) {
   if (typeof v !== "boolean") {
     const where = side ? ` (${side})` : "";
@@ -2308,6 +2319,30 @@ function fold(node) {
     }
     case 3 /* BinaryOp */: {
       const left = recurse(node.left);
+      if (node.operator === "&&") {
+        if (isBooleanLiteral(left) && !left.value) {
+          return preserveComments(node, boolean(false));
+        }
+        const right2 = recurse(node.right);
+        if (isBooleanLiteral(left) && isBooleanLiteral(right2)) {
+          return preserveComments(node, boolean(right2.value));
+        }
+        if (left === node.left && right2 === node.right)
+          return node;
+        return preserveComments(node, binaryOp(left, node.operator, right2));
+      }
+      if (node.operator === "||") {
+        if (isBooleanLiteral(left) && left.value) {
+          return preserveComments(node, boolean(true));
+        }
+        const right2 = recurse(node.right);
+        if (isBooleanLiteral(left) && isBooleanLiteral(right2)) {
+          return preserveComments(node, boolean(right2.value));
+        }
+        if (left === node.left && right2 === node.right)
+          return node;
+        return preserveComments(node, binaryOp(left, node.operator, right2));
+      }
       const right = recurse(node.right);
       if (isNumberLiteral(left) && isNumberLiteral(right)) {
         const result = evaluateBinaryOperation(node.operator, left.value, right.value);
@@ -2329,10 +2364,6 @@ function fold(node) {
           return preserveComments(node, boolean(left.value !== right.value));
       }
       if (isBooleanLiteral(left) && isBooleanLiteral(right)) {
-        if (node.operator === "&&")
-          return preserveComments(node, boolean(left.value && right.value));
-        if (node.operator === "||")
-          return preserveComments(node, boolean(left.value || right.value));
         if (node.operator === "==")
           return preserveComments(node, boolean(left.value === right.value));
         if (node.operator === "!=")
@@ -2459,7 +2490,7 @@ __export(exports_array, {
 var ARR_SORT = (a) => {
   assertArray(a, "ARR_SORT");
   if (a.length <= 1)
-    return a;
+    return [...a];
   const sorted = [...a];
   const elemType = typeOf(sorted[0]);
   sorted.sort((x, y) => {
@@ -2628,8 +2659,63 @@ function assertStringOrArray(v, context) {
     throw new TypeError(`${context} expected string or array, got ${typeOf(v)}`);
   }
 }
+function hasSurrogateCodeUnit(value) {
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 57343)
+      return true;
+  }
+  return false;
+}
+function codePointLength(value) {
+  let length = 0;
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343)
+        i++;
+    }
+    length++;
+  }
+  return length;
+}
+function stringLength(value) {
+  return hasSurrogateCodeUnit(value) ? codePointLength(value) : value.length;
+}
+function sliceString(value, start, end) {
+  if (!hasSurrogateCodeUnit(value))
+    return value.slice(start, end);
+  return Array.from(value).slice(start, end).join("");
+}
+function indexOfString(value, search) {
+  if (search === "")
+    return 0;
+  if (!hasSurrogateCodeUnit(value) && !hasSurrogateCodeUnit(search)) {
+    return value.indexOf(search);
+  }
+  const haystack = Array.from(value);
+  const needle = Array.from(search);
+  if (needle.length > haystack.length)
+    return -1;
+  const limit = haystack.length - needle.length;
+  for (let i = 0;i <= limit; i++) {
+    let found = true;
+    for (let j = 0;j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found)
+      return i;
+  }
+  return -1;
+}
 var LEN = (v) => {
   assertStringOrArray(v, "LEN");
+  if (typeof v === "string")
+    return stringLength(v);
   return v.length;
 };
 var SLICE = (v, start, end) => {
@@ -2637,8 +2723,12 @@ var SLICE = (v, start, end) => {
   assertNumber(start, "SLICE", "start");
   if (end !== undefined) {
     assertNumber(end, "SLICE", "end");
+    if (typeof v === "string")
+      return sliceString(v, start, end);
     return v.slice(start, end);
   }
+  if (typeof v === "string")
+    return sliceString(v, start);
   return v.slice(start);
 };
 var CONTAINS = (v, search) => {
@@ -2664,7 +2754,7 @@ var INDEX_OF = (v, search) => {
   assertStringOrArray(v, "INDEX_OF");
   if (typeof v === "string") {
     assertString(search, "INDEX_OF (search)");
-    return v.indexOf(search);
+    return indexOfString(v, search);
   }
   for (let i = 0;i < v.length; i++) {
     if (deepEquals(v[i], search))
@@ -2704,9 +2794,9 @@ __export(exports_datetime, {
 });
 var TODAY = () => Temporal.Now.plainDateISO();
 var DATE = (year, month, day) => {
-  assertNumber(year, "DATE", "year");
-  assertNumber(month, "DATE", "month");
-  assertNumber(day, "DATE", "day");
+  assertInteger(year, "DATE", "year");
+  assertInteger(month, "DATE", "month");
+  assertInteger(day, "DATE", "day");
   return new Temporal.PlainDate(year, month, day);
 };
 var YEAR = (date) => {
@@ -2874,12 +2964,12 @@ __export(exports_datetimefull, {
   COMBINE: () => COMBINE
 });
 var DATETIME = (year, month, day, hour, minute, second) => {
-  assertNumber(year, "DATETIME", "year");
-  assertNumber(month, "DATETIME", "month");
-  assertNumber(day, "DATETIME", "day");
-  assertNumber(hour, "DATETIME", "hour");
-  assertNumber(minute, "DATETIME", "minute");
-  assertNumber(second, "DATETIME", "second");
+  assertInteger(year, "DATETIME", "year");
+  assertInteger(month, "DATETIME", "month");
+  assertInteger(day, "DATETIME", "day");
+  assertInteger(hour, "DATETIME", "hour");
+  assertInteger(minute, "DATETIME", "minute");
+  assertInteger(second, "DATETIME", "second");
   return new Temporal.PlainDateTime(year, month, day, hour, minute, second);
 };
 var NOW = () => Temporal.Now.plainDateTimeISO();
@@ -2958,12 +3048,18 @@ var SQRT = (x) => {
   return Math.sqrt(x);
 };
 var MIN = (...values) => {
+  if (values.length === 0) {
+    throw new RangeError("MIN requires at least one argument");
+  }
   for (const value of values) {
     assertNumber(value, "MIN");
   }
   return Math.min(...values);
 };
 var MAX = (...values) => {
+  if (values.length === 0) {
+    throw new RangeError("MAX requires at least one argument");
+  }
   for (const value of values) {
     assertNumber(value, "MAX");
   }
@@ -2997,6 +3093,9 @@ var CLAMP = (value, min, max) => {
   assertNumber(value, "CLAMP", "value");
   assertNumber(min, "CLAMP", "min");
   assertNumber(max, "CLAMP", "max");
+  if (min > max) {
+    throw new RangeError(`CLAMP: min (${min}) must not exceed max (${max})`);
+  }
   return value < min ? min : value > max ? max : value;
 };
 
@@ -3072,9 +3171,9 @@ __export(exports_time, {
   ADD_HOURS: () => ADD_HOURS
 });
 var TIME = (hour, minute, second) => {
-  assertNumber(hour, "TIME", "hour");
-  assertNumber(minute, "TIME", "minute");
-  assertNumber(second, "TIME", "second");
+  assertInteger(hour, "TIME", "hour");
+  assertInteger(minute, "TIME", "minute");
+  assertInteger(second, "TIME", "second");
   return new Temporal.PlainTime(hour, minute, second);
 };
 var NOW_TIME = () => Temporal.Now.plainTimeISO();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "2.3.1",
+	"version": "2.3.2",
 	"description": "A minimal, high-performance multi-type expression language with lexer, parser, and interpreter. Optimized for browsers with type-safe execution.",
 	"keywords": [
 		"calculator",