pacc 8.11.6 → 9.1.0

package/README.md

@@ -546,6 +546,7 @@ Retrive attribute values from an object.
 
 *   `object` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** attribute value source
 *   `definitions` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** 
+*   `filter` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** 
 
 Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** values
 
@@ -565,12 +566,12 @@ Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/G
 
 ## tokens
 
-Split property path into tokens
+Split expression path into tokens.
 
 ### Parameters
 
 *   `string` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
-*   `options`   (optional, default `{}`)
+*   `context`   (optional, default `{}`)
 
 ## setAttribute
 
@@ -582,7 +583,7 @@ The name may be a property path like 'a.b.c'.
 *   `object` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** 
 *   `expression` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
 *   `value` **any** 
-*   `definition` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** type def
+*   `definition` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)?** type def
 
 ## getAttribute
 
@@ -593,7 +594,7 @@ The name may be a property path like 'a.b.c' or a\[2]
 
 *   `object` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** 
 *   `expression` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
-*   `definition`  
+*   `definition` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)?** 
 
 Returns **any** value associated with the given property name
 
@@ -654,8 +655,8 @@ Type: [Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Globa
 *   `str` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
 *   `precedence` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?**  (optional, default `0`)
 *   `type` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** 
-*   `led` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?**  (optional, default `()=>{}`)
-*   `nud`   (optional, default `()=>{}`)
+*   `led` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?**  (optional, default `(parser,node)=>node`)
+*   `nud`   (optional, default `parser=>this`)
 
 Returns **[Token](#token)** 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "8.11.6",
+  "version": "9.1.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -17,6 +17,7 @@
   "keywords": [
     "attributes",
     "filtering",
+    "pratt",
     "property path",
     "xpath"
   ],

package/src/ast.mjs

@@ -4,39 +4,8 @@
  */
 
 export function pathEval(node, current, context) {
-  let collection = false;
-  let first = true;
   for (const item of node.path) {
-    switch (typeof item) {
-      case "string":
-      case "number":
-        switch (typeof current) {
-          case "undefined":
-            current = context.getGlobal(item);
-            break;
-          default:
-            if (collection) {
-              current = current.map(x => x[item]);
-            } else {
-              current =
-                current instanceof Map ? current.get(item) : current[item];
-
-              if (first && current === undefined) {
-                current = context.getGlobal(item);
-              }
-            }
-        }
-        break;
-      case "object":
-        if (typeof current.values === "function") {
-          current = current.values();
-        }
-
-        current = current.filter(c => item.eval(item, c, context));
-        collection = true;
-    }
-
-    first = false;
+    current = item.eval(item, current, context);
   }
 
   return current;
@@ -46,9 +15,60 @@ export function functionEval(node, current, context) {
   const args = node.args.map(a =>
     typeof a === "object" ? a.eval(a, current, context) : a
   );
-  return context.getGlobal(node.path[0])(...args);
+  return context.valueFor(node.name)(...args);
+}
+
+export function keyedAccessOrGlobalEval(node, current, context) {
+  return keyedAccessEval(node, current, context) ?? context.valueFor(node.key);
+}
+
+export function keyedAccessEval(node, current, context) {
+  if (current === undefined) {
+    return undefined;
+  }
+  if (current instanceof Map) {
+    return current.get(node.key);
+  }
+  if (current instanceof Set) {
+    return current.has(node.key) ? node.key : undefined;
+  }
+  if (current instanceof Iterator) {
+    return current.map(item => item[node.key]);
+  }
+
+  switch (typeof current[node.key]) {
+    case "function": {
+      const value = current[node.key]();
+
+      if (typeof value[Symbol.iterator] === "function") {
+        return [...value];
+        //return value[Symbol.iterator]();
+      }
+      return value;
+    }
+    case "undefined":
+      return context.valueFor(node.key, current);
+  }
+
+  return current[node.key];
+}
+
+export function filterEval(node, current, context) {
+  if (typeof current.values === "function") {
+    current = current.values();
+  }
+
+  return current.filter(item => node.filter.eval(node.filter, item, context));
+}
+
+export function nullFilterEval(node, current, context) {
+  if (typeof current.values === "function") {
+    current = current.values();
+  }
+
+  return current;
 }
 
-export const ASTTrue = {
-  eval: () => true
+export const ASTNullFilter = {
+  eval: nullFilterEval
 };

package/src/expand.mjs

@@ -1,4 +1,4 @@
-import { parse } from "./expression.mjs";
+import { parse } from "./parser.mjs";
 
 const maxNestingLevel = 8;
 

package/src/module.mjs

@@ -7,7 +7,7 @@ export * from "./filter.mjs";
 export * from "./multiple.mjs";
 export * from "./common-attributes.mjs";
 export * from "./properties.mjs";
-export * from "./expression.mjs";
+export * from "./parser.mjs";
 export * from "./expand.mjs";
 export * from "./environment.mjs";
 export {

package/src/multiple.mjs

@@ -15,21 +15,17 @@ export function setAttributes(object, source, definitions, cb) {
     let value = getAttribute(source, name);
 
     if (value === undefined) {
-      if (def.default === undefined) {
+      if (
+        def.default === undefined ||
+        getAttribute(object, name) !== undefined
+      ) {
         continue;
-      } else {
-        if (getAttribute(object, name, def) !== undefined) {
-          continue;
-        }
-        value = def.default;
       }
+      value = def.default;
     }
 
-    if (def.set) {
-      def.set.call(object, value, def);
-    } else {
-      setAttribute(object, name, value, def);
-    }
+    setAttribute(object, name, value, def);
+
     if (cb) {
       cb(def, name, value);
     }
@@ -40,12 +36,13 @@ export function setAttributes(object, source, definitions, cb) {
  * Retrive attribute values from an object.
  * @param {Object} object attribute value source
  * @param {Object} definitions
+ * @param {Function} [filter]
  * @return {Object} values
  */
-export function getAttributes(object, definitions) {
+export function getAttributes(object, definitions, filter) {
   const result = {};
 
-  for (const [path, def] of attributeIterator(definitions)) {
+  for (const [path, def] of attributeIterator(definitions, filter)) {
     const name = path.join(".");
 
     const value = getAttribute(object, name, def);

package/src/{expression.mjs → parser.mjs}

@@ -1,10 +1,8 @@
 import { tokens, EOF } from "./tokens.mjs";
 
 export function parseOnly(input, context = {}) {
-  context.getGlobal ||= a => globals[a];
-
   input = tokens(input, context);
-
+  
   let node, token, value;
 
   function advance() {
@@ -42,7 +40,7 @@ export function parseOnly(input, context = {}) {
     expression(precedence) {
       const last = token;
       advance();
-      node = last.nud ? last.nud(parser) : last;
+      node = last.nud(parser);
 
       while (token.precedence > precedence) {
         const last = token;
@@ -63,35 +61,3 @@ export function parse(input, context) {
   const result = parseOnly(input, context);
   return result.eval ? result.eval(result, context.root, context) : result;
 }
-
-export const globals = {
-  in: (a, b) => {
-    if (b?.[Symbol.iterator]) {
-      for (const x of b) {
-        if (x === a) {
-          return true;
-        }
-      }
-    }
-    return false;
-  },
-  ceil: Math.ceil,
-  floor: Math.floor,
-  abs: Math.abs,
-  min: Math.min,
-  max: Math.max,
-  encodeURI: encodeURI,
-  decodeURI: decodeURI,
-  encodeURIComponent: encodeURIComponent,
-  decodeURIComponent: decodeURIComponent,
-  trim: a => a.trim(),
-  uppercase: a => a.toUpperCase(),
-  lowercase: a => a.toLowerCase(),
-  substring: (s, a, b) => s.substring(a, b),
-  length: s => s.length,
-  join: (separator, ...args) =>
-    args
-      .map(item => (item instanceof Iterator ? Array.from(item) : item))
-      .flat()
-      .join(separator)
-};

package/src/settergetter.mjs

@@ -19,8 +19,9 @@ import {
   NUMBER,
   BOOLEAN
 } from "./tokens.mjs";
-import { parseOnly } from "./expression.mjs";
+import { parseOnly, parse } from "./parser.mjs";
 import { toInternal } from "./attributes.mjs";
+import { keyedAccessOrGlobalEval, keyedAccessEval, pathEval } from "./ast.mjs";
 
 /**
  * Set object attribute.
@@ -28,31 +29,43 @@ import { toInternal } from "./attributes.mjs";
  * @param {Object} object
  * @param {string} expression
  * @param {any} value
- * @param {Object} definition type def
+ * @param {Object} [definition] type def
  */
 export function setAttribute(object, expression, value, definition) {
-  const { path } = parseOnly(expression);
+  if(definition?.set) {
+    definition.set.call(object, value, definition);
+    return;
+  }
 
-  let anchor, anchorKey;
+  const context = {};
+  const ast = parseOnly(expression, context);
 
-  for (const key of path) {
-    if (anchor) {
-      anchor[anchorKey] = object = typeof key === "string" ? {} : [];
-      anchor = undefined;
-    }
+  let parent, parentItem;
 
-    const next = object[key];
+  switch (ast.eval) {
+    case keyedAccessEval:
+    case keyedAccessOrGlobalEval:
+      object[ast.key] = toInternal(value, definition);
+      break;
 
-    if (next === undefined || typeof next !== "object") {
-      anchor = object;
-      anchorKey = key;
-    } else {
-      object = next;
-    }
-  }
+    case pathEval:
+      for (const item of ast.path) {
+        if (typeof object !== "object") {
+          object = typeof item.key === "number" ? [] : {};
+          parent[parentItem.key] = object;
+        }
+
+        parent = object;
+        parentItem = item;
+
+        object = item.eval(item, object, context);
+      }
 
-  if (anchor) {
-    anchor[anchorKey] = toInternal(value, definition);
+      parent[parentItem.key] = toInternal(value, definition);
+      break;
+
+      default:
+        console.log("UKNOWN AST",ast);
   }
 }
 
@@ -61,34 +74,11 @@ export function setAttribute(object, expression, value, definition) {
  * The name may be a property path like 'a.b.c' or a[2]
  * @param {Object} object
  * @param {string} expression
+ * @param {Object} [definition]
  * @returns {any} value associated with the given property name
  */
 export function getAttribute(object, expression, definition) {
-  const { path } = parseOnly(expression);
-
-  for (const key of path) {
-    if (object !== undefined) {
-      switch (typeof object[key]) {
-        case "function":
-          object = object[key]();
-          if (typeof object[Symbol.iterator] === "function") {
-            object = [...object];
-          }
-          break;
-        default:
-          object = object[key];
-          break;
-        case "undefined":
-          return undefined;
-      }
-    }
-  }
-
-  if (object === undefined && definition) {
-    object = definition.default;
-  }
-
-  return object;
+  return parse(expression, { root: object }) ?? definition?.default;
 }
 
 /**

package/src/tokens.mjs

@@ -1,4 +1,11 @@
-import { pathEval, ASTTrue, functionEval } from "./ast.mjs";
+import {
+  pathEval,
+  ASTNullFilter,
+  keyedAccessEval,
+  keyedAccessOrGlobalEval,
+  filterEval,
+  functionEval
+} from "./ast.mjs";
 
 /**
  * Token lookup
@@ -22,8 +29,8 @@ function createToken(
   str,
   precedence = 0,
   type,
-  led = () => {},
-  nud = () => {}
+  led = (parser, node) => node,
+  nud = parser => this
 ) {
   const token = { str, precedence, type };
 
@@ -146,18 +153,16 @@ export /** @type {Token} */ const LESS_EQUAL = createBinopToken(
 );
 export /** @type {Token} */ const OPEN_ROUND = createToken(
   "(",
-  40,
+  100,
   "prefix",
-   (parser, left) => {
+  (parser, left) => {
     const args = parser.expression(0);
     parser.expect(CLOSE_ROUND);
-  
-    // TODO why is there a right side ?
-    const node = left.right || left;
-    node.eval = functionEval;
-    node.args = Array.isArray(args) ? args : [args];
-  
-    return left;
+    return {
+      eval: functionEval,
+      name: left.key,
+      args: Array.isArray(args) ? args : [args]
+    };
   },
   parser => {
     const result = parser.expression(0);
@@ -167,38 +172,40 @@ export /** @type {Token} */ const OPEN_ROUND = createToken(
 );
 
 export /** @type {Token} */ const CLOSE_ROUND = createToken(")", 0);
+
+function createFilter(parser) {
+  if (parser.token === CLOSE_BRACKET) {
+    parser.advance();
+    return ASTNullFilter;
+  }
+
+  const filter = parser.expression(0);
+  parser.expect(CLOSE_BRACKET);
+
+  switch (typeof filter) {
+    case "string":
+    case "number":
+      return { eval: keyedAccessEval, key: filter };
+    default:
+      return { eval: filterEval, filter };
+  }
+}
+
 export /** @type {Token} */ const OPEN_BRACKET = createToken(
   "[",
-  10,
+  80,
   "prefix",
   (parser, left) => {
-    if (parser.token === CLOSE_BRACKET) {
-      parser.advance();
-      left.path.push(ASTTrue);
-    } else {
-      const predicate = parser.expression(0);
-      parser.expect(CLOSE_BRACKET);
-      left.path.push(predicate);
-    }
-    return left;
-  },
-  parser => {
-    if (parser.token === CLOSE_BRACKET) {
-      parser.advance();
-      return ASTTrue;
-    }
+    const node = createFilter(parser);
 
-    const node = parser.expression(0);
-    parser.expect(CLOSE_BRACKET);
-
-    switch (typeof node) {
-      case "string":
-      case "number":
-        return { eval: pathEval, path: [node] };
+    if (left.key) {
+      return { eval: pathEval, path: [left, node] };
     }
 
-    return node;
-  }
+    left.path.push(node);
+    return left;
+  },
+  parser => createFilter(parser)
 );
 
 export /** @type {Token} */ const CLOSE_BRACKET = createToken("]", 0);
@@ -207,19 +214,27 @@ export /** @type {Token} */ const CLOSE_CURLY = createToken("}");
 export /** @type {Token} */ const QUESTION = createToken("?", 20, "infix");
 export /** @type {Token} */ const COLON = createToken(":", undefined, "infix");
 export /** @type {Token} */ const SEMICOLON = createToken(";");
-export /** @type {Token} */ const COMMA = createToken(",",20,"infix",(left,right)=>Array.isArray(left) ? [...left,right] : [left,right]);
+export /** @type {Token} */ const COMMA = createToken(
+  ",",
+  20,
+  "infix",
+  (left, right) => (Array.isArray(left) ? [...left, right] : [left, right])
+);
 
 export /** @type {Token} */ const DOT = createToken(
   ".",
   80,
   "infix",
   (left, right) => {
+    if (right.eval === keyedAccessOrGlobalEval) {
+      right.eval = keyedAccessEval;
+    }
     if (left.path) {
-      right.path.unshift(...left.path);
-    } else {
-      right.path.unshift(left);
+      left.path.push(right);
+      return left;
     }
-    return right;
+
+    return { eval: pathEval, path: [left, right] };
   }
 );
 export /** @type {Token} */ const AMPERSAND = createToken("&");
@@ -242,7 +257,7 @@ export /** @type {Token} */ const IDENTIFIER = createToken(
   undefined,
   undefined,
   parser => {
-    return { eval: pathEval, path: [parser.value] };
+    return { eval: keyedAccessOrGlobalEval, key: parser.value };
   }
 );
 
@@ -279,11 +294,6 @@ export /** @type {Token} */ const EOF = createToken(
   }
 );
 
-export const keywords = {
-  true: [BOOLEAN, true],
-  false: [BOOLEAN, false]
-};
-
 const esc = {
   b: "\b",
   f: "\f",
@@ -293,20 +303,65 @@ const esc = {
   v: "\v"
 };
 
+export const keywords = {
+  true: [BOOLEAN, true],
+  false: [BOOLEAN, false]
+};
+
+export const globals = {
+  in: (a, b) => {
+    if (b?.[Symbol.iterator]) {
+      for (const x of b) {
+        if (x === a) {
+          return true;
+        }
+      }
+    }
+    return false;
+  },
+  ceil: Math.ceil,
+  floor: Math.floor,
+  abs: Math.abs,
+  min: Math.min,
+  max: Math.max,
+  encodeURI: encodeURI,
+  decodeURI: decodeURI,
+  encodeURIComponent: encodeURIComponent,
+  decodeURIComponent: decodeURIComponent,
+  trim: a => a.trim(),
+  uppercase: a => a.toUpperCase(),
+  lowercase: a => a.toLowerCase(),
+  substring: (s, a, b) => s.substring(a, b),
+  length: s => s.length,
+  join: (separator, ...args) =>
+    args
+      .map(item => (item instanceof Iterator ? Array.from(item) : item))
+      .flat()
+      .join(separator),
+  sort: data => {
+    return data.sort();
+  },
+  truncate: (data, length) => {
+    data.length = length;
+    return data;
+  }
+};
+
 /**
- * Split property path into tokens
+ * Split expression path into tokens.
  * @generator
  * @param {string} string
  * @yields {Token}
  */
-export function* tokens(string, options = {}) {
-  options.keywords ||= keywords;
-  options.parseFloat ||= parseFloat;
+export function* tokens(string, context = {}) {
+  context.keywords ||= keywords;
+  context.parseFloat ||= parseFloat;
+  context.valueFor ||= (name, at) => globals[name];
 
   let state, value, hex, quote;
 
   const keywordOrIdentifier = () =>
-    options.keywords[value] || [IDENTIFIER, value];
+    context.keywords[value] || [IDENTIFIER, value];
   const startString = c => {
     value = "";
     state = "string";
@@ -343,7 +398,7 @@ export function* tokens(string, options = {}) {
       case " ":
         switch (state) {
           case "number":
-            yield [NUMBER, options.parseFloat(value)];
+            yield [NUMBER, context.parseFloat(value)];
             state = undefined;
           case undefined:
             break;
@@ -372,7 +427,7 @@ export function* tokens(string, options = {}) {
       case "'":
         switch (state) {
           case "number":
-            yield [NUMBER, options.parseFloat(value)];
+            yield [NUMBER, context.parseFloat(value)];
           case undefined:
             startString(c);
             break;
@@ -400,7 +455,7 @@ export function* tokens(string, options = {}) {
       case "|":
         switch (state) {
           case "number":
-            yield [NUMBER, options.parseFloat(value)];
+            yield [NUMBER, context.parseFloat(value)];
           case undefined:
             state = c;
             break;
@@ -431,7 +486,7 @@ export function* tokens(string, options = {}) {
       case "=":
         switch (state) {
           case "number":
-            yield [NUMBER, options.parseFloat(value)];
+            yield [NUMBER, context.parseFloat(value)];
           case undefined:
             state = c;
             break;
@@ -472,7 +527,7 @@ export function* tokens(string, options = {}) {
       case "}":
         switch (state) {
           case "number":
-            yield [NUMBER, options.parseFloat(value)];
+            yield [NUMBER, context.parseFloat(value)];
           case undefined:
             state = c;
             break;
@@ -523,7 +578,7 @@ export function* tokens(string, options = {}) {
       default:
         switch (state) {
           case "number":
-            yield [NUMBER, options.parseFloat(value)];
+            yield [NUMBER, context.parseFloat(value)];
           case undefined:
             state = "identifier";
             value = c;
@@ -546,7 +601,7 @@ export function* tokens(string, options = {}) {
     case "string":
       throw new Error("unterminated string", { cause: string });
     case "number":
-      yield [NUMBER, options.parseFloat(value)];
+      yield [NUMBER, context.parseFloat(value)];
       break;
     case "identifier":
       yield keywordOrIdentifier();

package/types/ast.d.mts

@@ -4,8 +4,12 @@
  */
 export function pathEval(node: any, current: any, context: any): any;
 export function functionEval(node: any, current: any, context: any): any;
-export namespace ASTTrue {
-    function eval(): boolean;
+export function keyedAccessOrGlobalEval(node: any, current: any, context: any): any;
+export function keyedAccessEval(node: any, current: any, context: any): any;
+export function filterEval(node: any, current: any, context: any): any;
+export function nullFilterEval(node: any, current: any, context: any): any;
+export namespace ASTNullFilter {
+    export { nullFilterEval as eval };
 }
 export type AST = {
     eval?: Function;

package/types/module.d.mts

@@ -7,7 +7,7 @@ export * from "./filter.mjs";
 export * from "./multiple.mjs";
 export * from "./common-attributes.mjs";
 export * from "./properties.mjs";
-export * from "./expression.mjs";
+export * from "./parser.mjs";
 export * from "./expand.mjs";
 export * from "./environment.mjs";
 export { setAttribute, getAttribute, getAttributeAndOperator } from "./settergetter.mjs";

package/types/multiple.d.mts

@@ -10,9 +10,10 @@ export function setAttributes(object: any, source: any, definitions: any, cb: Fu
  * Retrive attribute values from an object.
  * @param {Object} object attribute value source
  * @param {Object} definitions
+ * @param {Function} [filter]
  * @return {Object} values
  */
-export function getAttributes(object: any, definitions: any): any;
+export function getAttributes(object: any, definitions: any, filter?: Function): any;
 /**
  * Retrive attribute values from an object.
  * @param {Object} object attribute value source

package/types/parser.d.mts

@@ -0,0 +1,2 @@
+export function parseOnly(input: any, context?: {}): any;
+export function parse(input: any, context: any): any;

package/types/settergetter.d.mts

@@ -4,17 +4,18 @@
  * @param {Object} object
  * @param {string} expression
  * @param {any} value
- * @param {Object} definition type def
+ * @param {Object} [definition] type def
  */
-export function setAttribute(object: any, expression: string, value: any, definition: any): void;
+export function setAttribute(object: any, expression: string, value: any, definition?: any): void;
 /**
  * Deliver attribute value.
  * The name may be a property path like 'a.b.c' or a[2]
  * @param {Object} object
  * @param {string} expression
+ * @param {Object} [definition]
  * @returns {any} value associated with the given property name
  */
-export function getAttribute(object: any, expression: string, definition: any): any;
+export function getAttribute(object: any, expression: string, definition?: any): any;
 /**
  * Deliver attribute value and operator.
  * The name may be a property path like 'a.b.c <='.

package/types/tokens.d.mts

@@ -1,10 +1,10 @@
 /**
- * Split property path into tokens
+ * Split expression path into tokens.
  * @generator
  * @param {string} string
  * @yields {Token}
  */
-export function tokens(string: string, options?: {}): Generator<any, void, unknown>;
+export function tokens(string: string, context?: {}): Generator<any, void, unknown>;
 export namespace PLUS {
     let str: string;
 }
@@ -46,6 +46,27 @@ export namespace keywords {
     let _false: (boolean | Token)[];
     export { _false as false };
 }
+export namespace globals {
+    export function _in(a: any, b: any): boolean;
+    export { _in as in };
+    export let ceil: (x: number) => number;
+    export let floor: (x: number) => number;
+    export let abs: (x: number) => number;
+    export let min: (...values: number[]) => number;
+    export let max: (...values: number[]) => number;
+    export let encodeURI: typeof globalThis.encodeURI;
+    export let decodeURI: typeof globalThis.decodeURI;
+    export let encodeURIComponent: typeof globalThis.encodeURIComponent;
+    export let decodeURIComponent: typeof globalThis.decodeURIComponent;
+    export function trim(a: any): any;
+    export function uppercase(a: any): any;
+    export function lowercase(a: any): any;
+    export function substring(s: any, a: any, b: any): any;
+    export function length(s: any): any;
+    export function join(separator: any, ...args: any[]): string;
+    export function sort(data: any): any;
+    export function truncate(data: any, length: any): any;
+}
 export type Token = {
     str: string;
 };

package/types/expression.d.mts

@@ -1,21 +0,0 @@
-export function parseOnly(input: any, context?: {}): any;
-export function parse(input: any, context: any): any;
-export namespace globals {
-    export function _in(a: any, b: any): boolean;
-    export { _in as in };
-    export let ceil: (x: number) => number;
-    export let floor: (x: number) => number;
-    export let abs: (x: number) => number;
-    export let min: (...values: number[]) => number;
-    export let max: (...values: number[]) => number;
-    export let encodeURI: typeof globalThis.encodeURI;
-    export let decodeURI: typeof globalThis.decodeURI;
-    export let encodeURIComponent: typeof globalThis.encodeURIComponent;
-    export let decodeURIComponent: typeof globalThis.decodeURIComponent;
-    export function trim(a: any): any;
-    export function uppercase(a: any): any;
-    export function lowercase(a: any): any;
-    export function substring(s: any, a: any, b: any): any;
-    export function length(s: any): any;
-    export function join(separator: any, ...args: any[]): string;
-}