pacc 10.4.1 → 10.5.0

package/README.md

@@ -589,7 +589,7 @@ Expand expressions inside of object graphs.
 *   `context` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** 
 
     *   `context.root` **any?** actual replacement values
-    *   `context.stopClass` **[function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** 
+    *   `context.stopClass` **[function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** do not expand instancif
     *   `context.leadIn` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** starting separator
     *   `context.leadOut` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** ending separator
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "10.4.1",
+  "version": "10.5.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -43,19 +43,14 @@
   },
   "devDependencies": {
     "@mitata/counters": "^0.0.8",
-    "aggregated-map": "^1.0.7",
+    "aggregated-map": "^1.0.8",
     "ava": "^8.0.1",
-    "browser-ava": "^2.3.65",
-    "c8": "^11.0.0",
+    "browser-ava": "^2.3.69",
+    "c8": "^12.0.0",
     "documentation": "^14.0.3",
     "mitata": "^1.0.34",
-    "semantic-release": "^25.0.5",
-    "typescript": "^6.0.3"
-  },
-  "overrides": {
-    "c8": {
-      "yargs": "^18.0.0"
-    }
+    "semantic-release": "^25.0.8",
+    "typescript": "^7.0.2"
   },
   "engines": {
     "node": ">=26.4.0"

package/src/tokens.mjs

@@ -15,8 +15,21 @@ const lookup = {};
 /**
  * @typedef {Object} Token
  * @property {string} str
+ * @property {number} precedence
+ * @property {Function} led
+ * @property {Function} nud
+ * 
  */
 
+/**
+ * 
+ * @param {Token} token 
+ */
+export function registerToken(token) {
+  lookup[token.str] = [token];
+  return token;
+}
+
 /**
  *
  * @param {string} str
@@ -48,8 +61,8 @@ function createToken(
   }
 
   token.nud = nud;
-  lookup[str] = [token];
-  return token;
+
+  return registerToken(token);
 }
 
 function createBinopToken(str, precedence, type, binop) {

package/types/ast.d.mts

@@ -2,15 +2,15 @@
  * @typedef {Object} AST
  * @property {Function} [eval]
  */
-export function pathEval(node: any, current: any, context: any): any;
-export function functionEval(node: any, current: any, context: any): any;
-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 | undefined;
+    eval?: Function;
+};
+export declare function pathEval(node: any, current: any, context: any): any;
+export declare function functionEval(node: any, current: any, context: any): any;
+export declare function keyedAccessOrGlobalEval(node: any, current: any, context: any): any;
+export declare function keyedAccessEval(node: any, current: any, context: any): any;
+export declare function filterEval(node: any, current: any, context: any): any;
+export declare function nullFilterEval(node: any, current: any, context: any): any;
+export declare const ASTNullFilter: {
+    eval: typeof nullFilterEval;
 };

package/types/attributes.d.mts

@@ -4,7 +4,7 @@
  * @param {Object} [presentDefinitions] optional merge in attributes
  * @return {Object} attributes
  */
-export function prepareAttributesDefinitions(newDefinitions: Object, presentDefinitions?: Object): Object;
+export declare function prepareAttributesDefinitions(newDefinitions: Object, presentDefinitions?: Object): Object;
 /**
  * Iterate over attributes.
  * @param {Object} attribute definition
@@ -12,7 +12,7 @@ export function prepareAttributesDefinitions(newDefinitions: Object, presentDefi
  * @param {string[]} [path]
  * @return {Iterable<[string[],object]>}
  */
-export function attributeIterator(definition: any, filter?: Function, path?: string[]): Iterable<[string[], object]>;
+export declare function attributeIterator(definition: any, filter?: Function, path?: string[]): Iterable<[string[], object]>;
 /**
  * Iterate over all attributes of a type.
  * @param {Type} type definition
@@ -20,10 +20,10 @@ export function attributeIterator(definition: any, filter?: Function, path?: str
  * @param {string[]} [path]
  * @return {Iterable<[string[],object]>}
  */
-export function extendingAttributeIterator(type: Type, filter?: Function, path?: string[]): Iterable<[string[], object]>;
-export function writableAttributeIterator(definition: any): Generator<[string[], object], void, any>;
-export function toInternal(value: any, attribute: any): any;
-export function toExternal(value: any, attribute: any): any;
-export function mandatoryAttributesPresent(object: any, attributes: any): boolean;
-export function filterWritable(attribute: any): any;
-export function filterPublic(attribute: any): boolean;
+export declare function extendingAttributeIterator(type: Type, filter?: Function, path?: string[]): Iterable<[string[], object]>;
+export declare const filterWritable: (attribute: any) => any;
+export declare const filterPublic: (attribute: any) => boolean;
+export declare function writableAttributeIterator(definition: any): Generator<[string[], object], void, any>;
+export declare function toInternal(value: any, attribute: any): any;
+export declare function toExternal(value: any, attribute: any): any;
+export declare function mandatoryAttributesPresent(object: any, attributes: any): boolean;

package/types/bytes.d.mts

@@ -1,7 +1,7 @@
-export function formatBytes(bytes: any, decimals?: number): string;
+export declare function formatBytes(bytes: any, decimals?: number): string;
 /**
  * Convert byte size formatted string into number of bytes.
  * @param {number|string} value
  * @returns {number} number of total bytes
  */
-export function parseBytes(value: number | string): number;
+export declare function parseBytes(value: number | string): number;

package/types/common-attributes.d.mts

@@ -1,3 +1,83 @@
+export type AttributeDefinition = {
+    name: string;
+    type: Type;
+    /**
+     * are we an identifying attribute
+     */
+    key: boolean;
+    /**
+     * can this attribute be modified
+     */
+    writable: boolean;
+    mandatory: boolean;
+    /**
+     * are we a collection (set, map, array, object)
+     */
+    collection: boolean;
+    /**
+     * should the value be shown
+     */
+    private?: boolean;
+    /**
+     * any type of credential
+     */
+    credential?: boolean;
+    /**
+     * should we be stored (especially critical for credentials)
+     */
+    persistent?: boolean;
+    backpointer?: AttributeDefinition;
+    /**
+     * (collection) constructor
+     */
+    constructor?: Function;
+    /**
+     * name of an attribute we depend on
+     */
+    depends?: string;
+    /**
+     * human readable
+     */
+    description?: string;
+    /**
+     * the default value
+     */
+    default?: any;
+    /**
+     * set the value
+     */
+    set?: Function;
+    /**
+     * get the value can be used to calculate default values
+     */
+    get?: Function;
+    toInternal?: Function;
+    toExternal?: Function;
+    /**
+     * deliver key and value for Map insertion
+     */
+    asMapEntry?: Function;
+    /**
+     * attribute name used by external system
+     */
+    externalName?: string;
+    /**
+     * allowed values
+     */
+    values?: Set<any>;
+    /**
+     * environment variable(s) used to provide the value
+     */
+    env?: string[] | string;
+    /**
+     * other values to be set in case our attribute is set
+     */
+    additionalValues?: object;
+    /**
+     * separator for collections
+     */
+    separator?: string;
+};
 /**
  * @typedef {Object} AttributeDefinition
  *
@@ -30,344 +110,300 @@
  * Common attribute properties.
  * @type {AttributeDefinition}
  */
-export const default_attribute: AttributeDefinition;
+export declare const default_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const default_attribute_writable: AttributeDefinition;
+export declare const default_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const default_collection_attribute: AttributeDefinition;
+export declare const default_collection_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const default_collection_attribute_writable: AttributeDefinition;
+export declare const default_collection_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const string_attribute: AttributeDefinition;
+export declare const string_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const string_attribute_writable: AttributeDefinition;
+export declare const string_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const string_collection_attribute: AttributeDefinition;
+export declare const string_collection_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const string_collection_attribute_writable: AttributeDefinition;
+export declare const string_collection_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const string_set_attribute: AttributeDefinition;
+export declare const string_set_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const string_set_attribute_writable: AttributeDefinition;
+export declare const string_set_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const name_attribute: AttributeDefinition;
+export declare const name_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const name_attribute_writable: AttributeDefinition;
+export declare const name_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const email_attribute: AttributeDefinition;
+export declare const email_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const version_attribute: AttributeDefinition;
+export declare const version_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const version_attribute_writable: AttributeDefinition;
+export declare const version_attribute_writable: AttributeDefinition;
 /**
  * The description of the object content.
  * @type {AttributeDefinition}
  */
-export const description_attribute: AttributeDefinition;
+export declare const description_attribute: AttributeDefinition;
+export { description_attribute as description_attribute_writable };
+/**
+ * @type {AttributeDefinition}
+ */
+export declare const type_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const type_attribute: AttributeDefinition;
+export declare const type_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const type_attribute_writable: AttributeDefinition;
+export declare const state_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const state_attribute_writable: AttributeDefinition;
+export declare const boolean_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const boolean_attribute: AttributeDefinition;
+export declare const boolean_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const boolean_attribute_writable: AttributeDefinition;
+export declare const boolean_attribute_writable_true: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const boolean_attribute_writable_true: AttributeDefinition;
+export declare const boolean_attribute_writable_false: AttributeDefinition;
+/**
+ * @type {AttributeDefinition}
+ */
+export declare const boolean_attribute_false: AttributeDefinition;
+/**
+ * @type {AttributeDefinition}
+ */
+export { boolean_attribute_writable_true as active_attribute };
+/**
+ * @type {AttributeDefinition}
+ */
+export declare const yesno_attribute: AttributeDefinition;
+export declare const yesno_attribute_writable: {
+    name: string;
+    type: Type;
+    key: boolean;
+    mandatory: boolean;
+    collection: boolean;
+    private?: boolean;
+    credential?: boolean;
+    persistent?: boolean;
+    backpointer?: AttributeDefinition;
+    constructor?: Function | undefined;
+    depends?: string;
+    description?: string;
+    default?: any;
+    set?: Function | undefined;
+    get?: Function | undefined;
+    toInternal?: Function | undefined;
+    toExternal?: Function | undefined;
+    asMapEntry?: Function | undefined;
+    externalName?: string;
+    values?: Set<any>;
+    env?: string[] | string;
+    additionalValues?: object;
+    separator?: string;
+    writable: boolean;
+};
 /**
  * @type {AttributeDefinition}
  */
-export const boolean_attribute_writable_false: AttributeDefinition;
+export declare const empty_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const boolean_attribute_false: AttributeDefinition;
+export declare const uuid_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const yesno_attribute: AttributeDefinition;
-export namespace yesno_attribute_writable {
-    export let writable: boolean;
-    export let name: string;
-    export let type: Type;
-    export let key: boolean;
-    export let mandatory: boolean;
-    export let collection: boolean;
-    let _private: boolean | undefined;
-    export { _private as private };
-    export let credential: boolean | undefined;
-    export let persistent: boolean | undefined;
-    export let backpointer: AttributeDefinition | undefined;
-    export let constructor: Function | undefined;
-    export let depends: string | undefined;
-    export let description: string | undefined;
-    let _default: any;
-    export { _default as default };
-    export let set: Function | undefined;
-    export let get: Function | undefined;
-    export let toInternal: Function | undefined;
-    export let toExternal: Function | undefined;
-    export let asMapEntry: Function | undefined;
-    export let externalName: string | undefined;
-    export let values: Set<any> | undefined;
-    export let env: string | string[] | undefined;
-    export let additionalValues: object | undefined;
-    export let separator: string | undefined;
-}
+export declare const secret_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const empty_attribute: AttributeDefinition;
+export declare const secret_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const uuid_attribute: AttributeDefinition;
+export declare const username_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const secret_attribute: AttributeDefinition;
+export declare const password_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const secret_attribute_writable: AttributeDefinition;
+export declare const token_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const username_attribute: AttributeDefinition;
+export { secret_attribute as certificate_attribute };
 /**
  * @type {AttributeDefinition}
  */
-export const password_attribute: AttributeDefinition;
+export declare const private_key_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const token_attribute: AttributeDefinition;
+export declare const public_key_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const private_key_attribute: AttributeDefinition;
+export declare const number_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const public_key_attribute: AttributeDefinition;
+export declare const number_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const number_attribute: AttributeDefinition;
+export declare const integer_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const number_attribute_writable: AttributeDefinition;
+export declare const integer_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const integer_attribute: AttributeDefinition;
+export { integer_attribute as count_attribute };
 /**
  * @type {AttributeDefinition}
  */
-export const integer_attribute_writable: AttributeDefinition;
+export { integer_attribute_writable as count_attribute_writable };
 /**
  * @type {AttributeDefinition}
  */
-export const size_attribute: AttributeDefinition;
-export namespace bytes_size_attribute {
-    let type_1: {
+export declare const size_attribute: AttributeDefinition;
+export declare const bytes_size_attribute: {
+    key: boolean;
+    writable: boolean;
+    mandatory: boolean;
+    collection: boolean;
+    private?: boolean;
+    credential?: boolean;
+    persistent?: boolean;
+    backpointer?: AttributeDefinition;
+    constructor?: Function | undefined;
+    depends?: string;
+    description?: string;
+    default?: any;
+    set?: Function | undefined;
+    get?: Function | undefined;
+    toInternal?: Function | undefined;
+    toExternal?: Function | undefined;
+    asMapEntry?: Function | undefined;
+    externalName?: string;
+    values?: Set<any>;
+    env?: string[] | string;
+    additionalValues?: object;
+    separator?: string;
+    type: {
         name: string;
         primitive: boolean;
         toInternal: typeof import("./bytes.mjs").parseBytes;
     };
-    export { type_1 as type };
-    let name_1: string;
-    export { name_1 as name };
-    let writable_1: boolean;
-    export { writable_1 as writable };
-}
+    name: string;
+};
 /**
  * @type {AttributeDefinition}
  */
-export const object_attribute: AttributeDefinition;
+export declare const object_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const url_attribute: AttributeDefinition;
+export declare const url_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const url_attribute_writable: AttributeDefinition;
+export declare const url_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const hostname_attribute: AttributeDefinition;
+export declare const hostname_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const port_attribute: AttributeDefinition;
+export declare const port_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const port_attribute_writable: AttributeDefinition;
+export declare const port_attribute_writable: AttributeDefinition;
 /**
  * Unique id within.
  * @type {AttributeDefinition}
  */
-export const id_attribute: AttributeDefinition;
+export declare const id_attribute: AttributeDefinition;
 /**
  * The body text.
  * @type {AttributeDefinition}
  */
-export const body_attribute_writable: AttributeDefinition;
+export declare const body_attribute_writable: AttributeDefinition;
 /**
  * The one line description.
  * @type {AttributeDefinition}
  */
-export const title_attribute_writable: AttributeDefinition;
+export declare const title_attribute_writable: AttributeDefinition;
 /**
  * In case there are several providers able to support a given source which one sould be used ?
  * this defines the order.
  * @type {AttributeDefinition}
  */
-export const priority_attribute: AttributeDefinition;
+export declare const priority_attribute: AttributeDefinition;
+/**
+ * @type {AttributeDefinition}
+ */
+export { priority_attribute as priority_attribute_writable };
 /**
  * Duration in seconds.
  * @type {AttributeDefinition}
  */
-export const duration_attribute: AttributeDefinition;
+export declare const duration_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const duration_attribute_writable: AttributeDefinition;
+export declare const duration_attribute_writable: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const duration_ms_attribute: AttributeDefinition;
+export declare const duration_ms_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const timeout_attribute: AttributeDefinition;
+export declare const timeout_attribute: AttributeDefinition;
 /**
  * @type {AttributeDefinition}
  */
-export const language_attribute: AttributeDefinition;
-export type AttributeDefinition = {
-    name: string;
-    type: Type;
-    /**
-     * are we an identifying attribute
-     */
-    key: boolean;
-    /**
-     * can this attribute be modified
-     */
-    writable: boolean;
-    mandatory: boolean;
-    /**
-     * are we a collection (set, map, array, object)
-     */
-    collection: boolean;
-    /**
-     * should the value be shown
-     */
-    private?: boolean | undefined;
-    /**
-     * any type of credential
-     */
-    credential?: boolean | undefined;
-    /**
-     * should we be stored (especially critical for credentials)
-     */
-    persistent?: boolean | undefined;
-    backpointer?: AttributeDefinition | undefined;
-    /**
-     * (collection) constructor
-     */
-    constructor?: Function | undefined;
-    /**
-     * name of an attribute we depend on
-     */
-    depends?: string | undefined;
-    /**
-     * human readable
-     */
-    description?: string | undefined;
-    /**
-     * the default value
-     */
-    default?: any;
-    /**
-     * set the value
-     */
-    set?: Function | undefined;
-    /**
-     * get the value can be used to calculate default values
-     */
-    get?: Function | undefined;
-    toInternal?: Function | undefined;
-    toExternal?: Function | undefined;
-    /**
-     * deliver key and value for Map insertion
-     */
-    asMapEntry?: Function | undefined;
-    /**
-     * attribute name used by external system
-     */
-    externalName?: string | undefined;
-    /**
-     * allowed values
-     */
-    values?: Set<any> | undefined;
-    /**
-     * environment variable(s) used to provide the value
-     */
-    env?: string | string[] | undefined;
-    /**
-     * other values to be set in case our attribute is set
-     */
-    additionalValues?: object | undefined;
-    /**
-     * separator for collections
-     */
-    separator?: string | undefined;
-};
-export { description_attribute as description_attribute_writable, boolean_attribute_writable_true as active_attribute, secret_attribute as certificate_attribute, integer_attribute as count_attribute, integer_attribute_writable as count_attribute_writable, priority_attribute as priority_attribute_writable };
+export declare const language_attribute: AttributeDefinition;

package/types/environment.d.mts

@@ -5,4 +5,4 @@
  * @param {string} instanceIdentifier part of variable name.
  * @return {Object|undefined} undefined if no suitable environment variables have been found
  */
-export function environmentValues(env: Object, attributes: Object, instanceIdentifier: string): Object | undefined;
+export declare function environmentValues(env: Object, attributes: Object, instanceIdentifier: string): Object | undefined;

package/types/expand.d.mts

@@ -1,3 +1,24 @@
+declare class _Dummy {
+}
+/**
+ * Default expand context
+ * using '§{' and '}' as lead in/out
+ */
+export declare const expandContextDefault: {
+    root: {};
+    leadIn: string;
+    leadOut: string;
+    stopClass: typeof _Dummy;
+};
+/**
+ * Expand context with doubble curly separaion '{{' '}}'
+ */
+export declare const expandContextDoubbleCurly: {
+    root: {};
+    stopClass: typeof _Dummy;
+    leadIn: string;
+    leadOut: string;
+};
 /**
  * Expand expressions inside of object graphs.
  * @param {any} object
@@ -8,24 +29,10 @@
  * @param {string} [context.leadOut] ending separator
  * @returns {any|Promise<any>}
  */
-export function expand(object: any, context: {
+export declare function expand(object: any, context: {
     root?: any;
-    stopClass?: Function | undefined;
-    leadIn?: string | undefined;
-    leadOut?: string | undefined;
+    stopClass?: Function;
+    leadIn?: string;
+    leadOut?: string;
 }): any | Promise<any>;
-export namespace expandContextDefault {
-    export let root: {};
-    export let leadIn: string;
-    export let leadOut: string;
-    export { _Dummy as stopClass };
-}
-export namespace expandContextDoubbleCurly {
-    let leadIn_1: string;
-    export { leadIn_1 as leadIn };
-    let leadOut_1: string;
-    export { leadOut_1 as leadOut };
-}
-declare class _Dummy {
-}
 export {};

package/types/extract.d.mts

@@ -1 +1 @@
-export function extract(object: any, type?: any): {};
+export declare function extract(object: any, type?: any): {};

package/types/filter.d.mts

@@ -3,4 +3,4 @@
  * @param {Object} [filterBy]
  * @returns {Function}
  */
-export function filter(filterBy?: Object): Function;
+export declare function filter(filterBy?: Object): Function;

package/types/multiple.d.mts

@@ -5,7 +5,7 @@
  * @param {Object} definitions attribute definitions to be used
  * @param {function?} cb callback to be executed for each copied value
  */
-export function setAttributes(object: Object, source: Object, definitions: Object, cb: Function | null): void;
+export declare function setAttributes(object: Object, source: Object, definitions: Object, cb: Function | null): void;
 /**
  * Retrive attribute values from an object.
  * @param {Object} object attribute value source
@@ -13,7 +13,7 @@ export function setAttributes(object: Object, source: Object, definitions: Objec
  * @param {Function} [filter]
  * @return {Object} values
  */
-export function getAttributes(object: Object, definitions: Object, filter?: Function): Object;
+export declare function getAttributes(object: Object, definitions: Object, filter?: Function): Object;
 /**
  * Retrive attribute values from an object.
  * @param {Object} object attribute value source
@@ -21,4 +21,4 @@ export function getAttributes(object: Object, definitions: Object, filter?: Func
  * @param {Function} [filter]
  * @return {Object} values
  */
-export function getAttributesJSON(object: Object, definitions: Object, filter?: Function): Object;
+export declare function getAttributesJSON(object: Object, definitions: Object, filter?: Function): Object;

package/types/parser.d.mts

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

package/types/properties.d.mts

@@ -1 +1 @@
-export function definePropertiesFromAttributes(object: any, attributes: any, initialValues: any, properties?: {}): void;
+export declare function definePropertiesFromAttributes(object: any, attributes: any, initialValues: any, properties?: {}): void;

package/types/settergetter.d.mts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import('./tokens.mjs').Token} Token
+ */
+export type Token = import('./tokens.mjs').Token;
 /**
  * Set object attribute.
  * The name may be a property path like 'a.b.c'.
@@ -6,7 +10,7 @@
  * @param {any} value
  * @param {Object} [definition] type def
  */
-export function setAttribute(object: Object, expression: string, value: any, definition?: Object): void;
+export declare function setAttribute(object: Object, expression: string, value: any, definition?: Object): void;
 /**
  * Deliver attribute value.
  * The name may be a property path like 'a.b.c' or a[2]
@@ -15,7 +19,7 @@ export function setAttribute(object: Object, expression: string, value: any, def
  * @param {Object} [definition]
  * @returns {any} value associated with the given property name
  */
-export function getAttribute(object: Object, expression: string, definition?: Object): any;
+export declare function getAttribute(object: Object, expression: string, definition?: Object): any;
 /**
  * Deliver attribute value and operator.
  * The name may be a property path like 'a.b.c <='.
@@ -23,5 +27,4 @@ export function getAttribute(object: Object, expression: string, definition?: Ob
  * @param {string} expression
  * @returns {[any,Token]} value associated with the given property name
  */
-export function getAttributeAndOperator(object: Object, expression: string): [any, Token];
-export type Token = import("./tokens.mjs").Token;
+export declare function getAttributeAndOperator(object: Object, expression: string): [any, Token];

package/types/time.d.mts

@@ -3,16 +3,16 @@
  * @param {number|string} value
  * @returns {number} seconds
  */
-export function parseDuration(value: number | string): number;
+export declare function parseDuration(value: number | string): number;
 /**
  *
  * @param {number} seconds
  * @returns {string} formatted duration
  */
-export function formatDuration(seconds: number): string;
+export declare function formatDuration(seconds: number): string;
 /**
  *
  * @param {number} seconds
  * @returns {string} formatted duration
  */
-export function formatDurationISO(seconds: number): string;
+export declare function formatDurationISO(seconds: number): string;

package/types/tokens.d.mts

@@ -1,3 +1,77 @@
+export type Token = {
+    str: string;
+    precedence: number;
+    led: Function;
+    nud: Function;
+};
+/**
+ * @typedef {Object} Token
+ * @property {string} str
+ * @property {number} precedence
+ * @property {Function} led
+ * @property {Function} nud
+ *
+ */
+/**
+ *
+ * @param {Token} token
+ */
+export declare function registerToken(token: Token): Token;
+export declare const PLUS: Token;
+export declare const MINUS: Token;
+export declare const STAR: Token;
+export declare const DIVIDE: Token;
+export declare const NOT: Token;
+export declare const NOT_EQUAL: Token;
+export declare const EQUAL: Token;
+export declare const GREATER: Token;
+export declare const GREATER_EQUAL: Token;
+export declare const LESS: Token;
+export declare const LESS_EQUAL: Token;
+export declare const OPEN_ROUND: Token;
+export declare const CLOSE_ROUND: Token;
+export declare const OPEN_BRACKET: Token;
+export declare const CLOSE_BRACKET: Token;
+export declare const OPEN_CURLY: Token;
+export declare const CLOSE_CURLY: Token;
+export declare const QUESTION: Token;
+export declare const COLON: Token;
+export declare const SEMICOLON: Token;
+export declare const COMMA: Token;
+export declare const DOT: Token;
+export declare const AMPERSAND: Token;
+export declare const DOUBLE_AMPERSAND: Token;
+export declare const BAR: Token;
+export declare const DOUBLE_BAR: Token;
+export declare const IDENTIFIER: Token;
+export declare const STRING: Token;
+export declare const NUMBER: Token;
+export declare const BOOLEAN: Token;
+export declare const EOF: Token;
+export declare const keywords: {
+    true: (boolean | Token)[];
+    false: (boolean | Token)[];
+};
+export declare const globals: {
+    in: (args: any, current: any, context: any) => boolean;
+    ceil: (args: any, current: any, context: any) => number;
+    floor: (args: any, current: any, context: any) => number;
+    abs: (args: any, current: any, context: any) => number;
+    min: (args: any, current: any, context: any) => number;
+    max: (args: any, current: any, context: any) => number;
+    encodeURI: (args: any, current: any, context: any) => string;
+    decodeURI: (args: any, current: any, context: any) => string;
+    encodeURIComponent: (args: any, current: any, context: any) => string;
+    decodeURIComponent: (args: any, current: any, context: any) => string;
+    trim: (args: any, current: any, context: any) => any;
+    length: (args: any, current: any, context: any) => any;
+    uppercase: (args: any, current: any, context: any) => any;
+    lowercase: (args: any, current: any, context: any) => any;
+    substring: (args: any, current: any, context: any) => any;
+    join: (args: any, current: any, context: any) => any;
+    sort: (args: any, current: any, context: any) => any;
+    truncate: (args: any, current: any, context: any) => any;
+};
 /**
  * Split expression path into tokens.
  * @generator
@@ -5,69 +79,4 @@
  * @param {Object} context
  * @yields {Token}
  */
-export function tokens(string: string, context: Object): Generator<any, void, unknown>;
-export namespace PLUS {
-    let str: string;
-}
-export namespace MINUS {
-    function nud(parser: any): number;
-}
-export namespace STAR { }
-export namespace DIVIDE { }
-export namespace NOT { }
-export namespace NOT_EQUAL { }
-export namespace EQUAL { }
-export namespace GREATER { }
-export namespace GREATER_EQUAL { }
-export namespace LESS { }
-export namespace LESS_EQUAL { }
-export namespace OPEN_ROUND { }
-export namespace CLOSE_ROUND { }
-export namespace OPEN_BRACKET { }
-export namespace CLOSE_BRACKET { }
-export namespace OPEN_CURLY { }
-export namespace CLOSE_CURLY { }
-export namespace QUESTION { }
-export namespace COLON { }
-export namespace SEMICOLON { }
-export namespace COMMA { }
-export namespace DOT { }
-export namespace AMPERSAND { }
-export namespace DOUBLE_AMPERSAND { }
-export namespace BAR { }
-export namespace DOUBLE_BAR { }
-export namespace IDENTIFIER { }
-export namespace STRING { }
-export namespace NUMBER { }
-export namespace BOOLEAN { }
-export namespace EOF { }
-export namespace keywords {
-    let _true: (boolean | Token)[];
-    export { _true as true };
-    let _false: (boolean | Token)[];
-    export { _false as false };
-}
-export namespace globals {
-    export function _in(args: any, current: any, context: any): boolean;
-    export { _in as in };
-    export function ceil(args: any, current: any, context: any): number;
-    export function floor(args: any, current: any, context: any): number;
-    export function abs(args: any, current: any, context: any): number;
-    export function min(args: any, current: any, context: any): number;
-    export function max(args: any, current: any, context: any): number;
-    export function encodeURI(args: any, current: any, context: any): string;
-    export function decodeURI(args: any, current: any, context: any): string;
-    export function encodeURIComponent(args: any, current: any, context: any): string;
-    export function decodeURIComponent(args: any, current: any, context: any): string;
-    export function trim(args: any, current: any, context: any): any;
-    export function length(args: any, current: any, context: any): any;
-    export function uppercase(args: any, current: any, context: any): any;
-    export function lowercase(args: any, current: any, context: any): any;
-    export function substring(args: any, current: any, context: any): any;
-    export function join(args: any, current: any, context: any): any;
-    export function sort(args: any, current: any, context: any): any;
-    export function truncate(args: any, current: any, context: any): any;
-}
-export type Token = {
-    str: string;
-};
+export declare function tokens(string: string, context: Object): Generator<any, void, unknown>;

package/types/types.d.mts

@@ -1,8 +1,25 @@
-export function addType(type: any): any;
-export function oneOfType(definition: any): any;
-export function resolveTypeLinks(): void;
-export function create(type: any, owner: any, data: any): any;
-export const types: {
+import { parseBytes } from "./bytes.mjs";
+export type Type = {
+    name: string;
+    primitive?: boolean;
+    extends?: Type;
+    members?: Set<Type>;
+    clazz?: Function;
+    toInternal?: Function;
+    toExternal?: Function;
+};
+/**
+ * @typedef {Object} Type
+ * @property {string} name
+ * @property {boolean} [primitive]
+ * @property {Type} [extends]
+ * @property {Set<Type>} [members]
+ * @property {Function} [clazz]
+ * @property {Function} [toInternal]
+ * @property {Function} [toExternal]
+ */
+declare const emptyStringIsUndefined: (value: any) => any;
+export declare const types: {
     string: {
         name: string;
         primitive: boolean;
@@ -54,20 +71,15 @@ export const types: {
     url: {
         name: string;
         primitive: boolean;
-        toInternal: (value: any) => any;
+        toInternal: typeof emptyStringIsUndefined;
     };
     object: {
         name: string;
         primitive: boolean;
     };
 };
-export type Type = {
-    name: string;
-    primitive?: boolean | undefined;
-    extends?: Type | undefined;
-    members?: Set<Type> | undefined;
-    clazz?: Function | undefined;
-    toInternal?: Function | undefined;
-    toExternal?: Function | undefined;
-};
-import { parseBytes } from "./bytes.mjs";
+export declare function addType(type: any): any;
+export declare function oneOfType(definition: any): any;
+export declare function resolveTypeLinks(): void;
+export declare function create(type: any, owner: any, data: any): any;
+export {};