markuno_lib 1.1.26 → 1.1.27

package/package.json

@@ -1,26 +1,50 @@
 {
   "name": "markuno_lib",
-  "version": "1.1.26",
+  "version": "1.1.27",
   "description": "Croswil Markuno Language Lib",
-  "main": "bin/index.js",
   "authors": [
     "Croswil <info@croswil.com>"
   ],
   "license": "ISC",
   "type": "module",
-  "dependencies": {},
   "exports": {
-    ".": "./bin/markuno.js",
-    "./proto": "./bin/proto.js",
-    "./bus": "./bin/bus_utils.js",
-    "./cad": "./bin/markcad.js",
-    "./cad3d": "./bin/markcad3d.js",
-    "./marked": "./bin/marked.js"
+    ".": {
+      "import": "./bin/markuno.js",
+      "require": "./bin/markuno.js",
+      "types": "./types/markuno.d.ts"
+    },
+    "./proto": {
+      "import": "./bin/proto.js",
+      "require": "./bin/proto.js",
+      "types": "./types/proto.d.ts"
+    },
+    "./bus": {
+      "import": "./bin/bus_utils.js",
+      "require": "./bin/bus_utils.js",
+      "types": "./types/bus_utils.d.ts"
+    },
+    "./cad": {
+      "import": "./bin/markcad.js",
+      "require": "./bin/markcad.js",
+      "types": "./types/markcad.d.ts"
+    },
+    "./cad3d": {
+      "import": "./bin/markcad3d.js",
+      "require": "./bin/markcad3d.js",
+      "types": "./types/markcad3d.d.ts"
+    },
+    "./marked": {
+      "import": "./bin/marked.js",
+      "require": "./bin/marked.js",
+      "types": "./types/marked.d.ts"
+    }
   },
-  "files": [
-    "bin/**"
-  ],
   "imports": {
     "#markuno_cad": "./bin/markcad.js"
-  }
+  },
+  "files": [
+    "bin/**",
+    "types/**"
+  ],
+  "dependencies": {}
 }

package/types/bus_utils.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Implementa un sistema di eventi publish/subscribe
+ */ export const bus: {
+    buslist: {};
+    /**
+         * Registra un handler per un evento
+         * @param {string} des - Nome dell'evento
+         * @param {Function} func - Handler da eseguire
+         * @returns {number} Indice dell'handler nella lista
+         */ on(des: string, func: Function): number;
+    /**
+         * Emette un evento con i relativi parametri
+         * @param {string} des - Nome dell'evento
+         * @param {...any} args - Parametri da passare agli handler
+         */ emit(des: string, ...args: any[]): void;
+    /**
+         * Rimuove un handler per un evento
+         * @param {string} des - Nome dell'evento
+         * @param {Function|number} func - Handler da rimuovere o suo indice
+         */ off(des: string, func: Function | number): void;
+    $on(des: any, func: any): void;
+    $off(des: any, func: any): void;
+    $emit(des: any, ...args: any[]): void;
+};
+export function evalcustomfunction(amb: any, code: any, vv: any, objects: any): Promise<any>;
+/**
+ * Formatta una data nel formato YYYY-MM-DD
+ * @param {string|Date} dateString - La data da formattare
+ * @returns {string} La data formattata come YYYY-MM-DD
+ */ export function formatDate(dateString: string | Date): string;
+export function getdim(l: any, a: any, p: any, al: any, aa: any, ap: any, fmodl: any, fmoda: any, fmodp: any): string;
+/**
+ * Converte una stringa delimitata in array di oggetti {cod, des}
+ * @param {string|Array} x - Stringa con valori delimitati da \n ; o ,
+ * @returns {Array<{cod: string, des: string}>} Array di oggetti con codice e descrizione
+ */
+export function listfromstring(x: string | any[]): Array<{
+    cod: string;
+    des: string;
+}>;
+export function myuuid(): number;
+export function strDate(date: any, formato: any): any;
+/**
+ * Converte una data nel formato DD/MM/YYYY HH:mm
+ * @param {Date|number} date - La data da convertire
+ * @returns {string} La data formattata come DD/MM/YYYY HH:mm
+ */ export function toDateStr(date: Date | number): string;
+export function toEuro(n: any, gratis: any, des?: string): any;
+export function tonum(s: any, dec?: number): number;

package/types/markcad.d.ts

@@ -0,0 +1,411 @@
+/**
+ * Classe che rappresenta una linea 2D definita da due punti
+ */ export class Linea2 {
+    /**
+         * Crea una nuova linea 2D
+         * @param {number|Object} p1 - Coordinata x del primo punto o oggetto {x,y}
+         * @param {number|Object} p2 - Coordinata y del primo punto o oggetto {x,y}
+         * @param {number} [x2=null] - Coordinata x del secondo punto (opzionale)
+         * @param {number} [y2=null] - Coordinata y del secondo punto (opzionale)
+         */
+    constructor(p1: number | any, p2: number | any, x2?: number, y2?: number);
+    p1: Punto2;
+    p2: Punto2;
+    /**
+         * Restituisce una rappresentazione testuale della linea
+         * @returns {string} Stringa nel formato "p1-p2"
+         */ get dump(): string;
+    /**
+         * Calcola la differenza delle coordinate x dei punti
+         * @returns {number} Differenza x
+         */ get dx(): number;
+    /**
+         * Calcola la differenza delle coordinate y dei punti
+         * @returns {number} Differenza y
+         */ get dy(): number;
+    /**
+         * Calcola il quadrato della lunghezza della linea
+         * @returns {number} Lunghezza al quadrato
+         */ get len2(): number;
+    /**
+         * Calcola la lunghezza della linea
+         * @returns {number} Lunghezza
+         */ get len(): number;
+    /**
+         * Estende la linea di una certa lunghezza o fino all'intersezione con un'altra linea
+         * @param {number|Linea2} l - Lunghezza di estensione o linea da intersecare
+         * @returns {Linea2} Nuova linea estesa
+         */ estendi(l: number | Linea2): Linea2;
+    /**
+         * Calcola il vettore direzione normalizzato della linea
+         * @returns {Punto2} Vettore direzione
+         */ get direzione(): Punto2;
+    /**
+         * Calcola il vettore normale normalizzato della linea
+         * @returns {Punto2} Vettore normale
+         */ get normale(): Punto2;
+    /**
+         * Crea una nuova linea ruotata di un certo angolo
+         * @param {number} [angle=Math.PI/2] - Angolo di rotazione in radianti
+         * @param {number} [length=0] - Lunghezza della nuova linea
+         * @param {boolean} [fine=false] - Se true ruota attorno al primo punto, altrimenti al secondo
+         * @returns {Linea2} Nuova linea ruotata
+         */ ruotata(angle?: number, length?: number, fine?: boolean): Linea2;
+    /**
+         * Calcola un punto sulla direzione della linea a una certa distanza
+         * @param {Punto2} p1 - Punto di partenza
+         * @param {number} lunghezza - Distanza dal punto di partenza
+         * @returns {Punto2} Nuovo punto
+         */ puntosudirezione(p1: Punto2, lunghezza: number): Punto2;
+    /**
+         * Crea una nuova linea parallela a questa passante per un punto
+         * @param {Punto2} p1 - Punto di passaggio
+         * @param {number} lunghezza - Lunghezza della nuova linea
+         * @returns {Linea2} Nuova linea parallela
+         */ parallela(p1: Punto2, lunghezza: number): Linea2;
+    /**
+         * Calcola il punto di intersezione con un'altra linea
+         * @param {Linea2} line2 - Seconda linea
+         * @returns {Punto2|null} Punto di intersezione o null se parallele
+         */ intersezione(line2: Linea2): Punto2 | null;
+    onsegment(p: any, eps?: number): boolean;
+    /**
+         * Verifica se la linea è parallela a un'altra
+         * @param {Linea2} line2 - Seconda linea
+         * @returns {boolean} True se parallele
+         */ isparallela(line2: Linea2): boolean;
+    /**
+      * Restituisce alcune info sul “quadrilatero” formato da questa linea e da line2,
+      * assumendo che siano parallele e abbiano verso invertito.
+      * @param {Linea2} line2
+      * @returns {Object|undefined}
+      *   { angle, aini, afin, l, distanza } oppure undefined se non parallele o degenere
+      */ infoquad(line2: Linea2): any | undefined;
+    /**
+         * Verifica se la linea è perpendicolare a un'altra
+         * @param {Linea2} line2 - Seconda linea
+         * @returns {boolean} True se perpendicolari
+         */ isperpendicolare(line2: Linea2): boolean;
+    /**
+         * Crea una nuova linea parallela a questa a una certa distanza
+         * @param {number} delta - Distanza di offset (positiva a sinistra, negativa a destra)
+         * @returns {Linea2} Nuova linea parallela
+         */ offset(delta: number): Linea2;
+    /**
+         * Calcola l'angolo tra questa linea e un'altra
+         * @param {Linea2} line2 - Seconda linea
+         * @returns {number} Angolo in radianti
+         */ angolo(line2: Linea2): number;
+    ortopt(l: any): {
+        x: any;
+        y: any;
+    };
+    offsetline(l: any): Linea2;
+    /**
+         * Calcola la distanza tra due segmenti paralleli
+         * @param {Linea2} line2 - Seconda linea
+         * @returns {number} Distanza tra i segmenti o 1e9 se non paralleli
+         */ distanzaSegmentiParalleli(line2: Linea2): number;
+    /**
+         * Verifica se due linee sono collineari
+         * @param {Linea2} line2 - Seconda linea
+         * @param {boolean} [checkpunticomune=false] - Se true verifica anche la sovrapposizione
+         * @returns {boolean} True se collineari
+         */ isCollineare(line2: Linea2, checkpunticomune?: boolean): boolean;
+}
+export class Matrix3D {
+    m: Float32Array;
+    st: any[];
+    init(): this;
+    atranslate(x: any, y: any, z: any): this;
+    translate(x: any, y: any, z: any): this;
+    rotateX(angolo: any): this;
+    rotateY(angolo: any): this;
+    rotateZ(angolo: any): this;
+    getdati(): number[];
+    setdati(d: any): this;
+    push(): this;
+    pop(): this;
+    transform(x: any, y: any, z?: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    invert(): Matrix3D;
+    determinant(): number;
+    multiply(matrix: any): this;
+}
+export const PIF: number;
+/** Tolleranza utilizzata per i confronti numerici */
+/**
+ * Classe che rappresenta un punto 2D con coordinate x,y
+ * @class
+ */
+export class Punto2 {
+    /**
+         * Crea un nuovo punto 2D
+         * @param {number|Array|Object} x - Coordinata x, array [x,y] o oggetto {x,y}
+         * @param {number} [y] - Coordinata y se x è un numero
+         */
+    constructor(x: number | any[] | any, y?: number);
+    x: any;
+    y: any;
+    /**
+         * Restituisce una rappresentazione testuale del punto
+         * @returns {string} Stringa nel formato {x,y}
+         */ get dump(): string;
+    /**
+         * Calcola il quadrato della lunghezza del vettore dal punto all'origine
+         * @returns {number} Lunghezza al quadrato
+         */ get len2(): number;
+    /**
+         * Calcola la lunghezza del vettore dal punto all'origine
+         * @returns {number} Lunghezza del vettore
+         */ get len(): number;
+    /**
+         * Calcola l'angolo del vettore rispetto all'asse x
+         * @returns {number} Angolo in radianti
+         */ get angle(): number;
+    /**
+         * Restituisce il vettore normalizzato (lunghezza unitaria)
+         * @returns {Punto2} Nuovo punto con le coordinate normalizzate
+         */ dir(): Punto2;
+}
+declare var splitter: Readonly<{
+    __proto__: any;
+    addhoriz: (ff: any, tipodim: any, dim: any, sps: any, des: any, align: any, cuts: any) => void;
+    addvert: (ff: any, tipodim: any, dim: any, sps: any, des: any, align: any, cuts: any) => void;
+    bordi: typeof bordi;
+    calcoladivisioni: (ff: any, shape: any, shape2: any) => any;
+    creabordi: typeof creabordi;
+    create: (x: any, y: any, bordo: any, options: any) => {
+        x: any;
+        y: any;
+        bordo: any;
+        minvano: any;
+        priority: any;
+        taglio: any;
+        tipo: any;
+        h1: any;
+        h2: any;
+        l1: any;
+        l2: any;
+        vert: any[];
+        horiz: any[];
+        dati: any[];
+        countid: number;
+    };
+    findid: (ff: any, id: any) => {
+        f: any;
+    };
+    generatesegments: typeof generatesegments;
+    internalshape: typeof internalshape;
+    makeshape: (ff: any) => {
+        shape: any;
+        internalshape: any;
+    };
+    priorita: {
+        v: string;
+        h: string;
+    };
+    pushlineare: typeof pushlineare;
+    pushshape: typeof pushshape;
+    tagli: {
+        d: string;
+        v: string;
+        h: string;
+    };
+    tipi: {
+        i: string;
+        a: string;
+        d: string;
+        s: string;
+        x: string;
+    };
+    tipoalign: {
+        l: string;
+        c: string;
+        r: string;
+    };
+    tipocut: {
+        d: string;
+        "d-": string;
+        p: string;
+        "p-": string;
+    };
+}>;
+export class Vis2d {
+    constructor(name: any, p1: any, p2: any);
+    name: any;
+    clear(p1: any, p2: any): this;
+    vec: any[];
+    xp1: any;
+    xp2: any;
+    randomcolor(transp?: string): string;
+    addpoint(p: any, id?: number, color?: any, spessore?: number): this;
+    addline(l: any, id?: number, color?: any, spessore?: number): this;
+    addrect(l: any, id?: number, color?: any, spessore?: number): this;
+    addrecta(l: any, id?: number, color?: any): this;
+    addshape(s: any, color?: any, spessore?: number): this;
+    addshapelin(s: any, color?: any, spessore?: number): this;
+    addarea(s: any, color?: any): this;
+    addoffset(x: any, y: any): this;
+}
+/**
+ * Calcola l'angolo tra due vettori in gradi.
+ * @param {Object} v1 - Primo vettore {x,y}
+ * @param {Object} v2 - Secondo vettore {x,y}
+ * @returns {number} Angolo in gradi
+ */ export function angle2vec(v1: any, v2: any): number;
+/**
+ * Calcola l'angolo tra tre punti in radianti.
+ * @param {Object} p1 - Primo punto {x,y}
+ * @param {Object} p2 - Punto centrale {x,y}
+ * @param {Object} p3 - Terzo punto {x,y}
+ * @returns {number} Angolo in radianti
+ */ export function angle3point(p1: any, p2: any, p3: any): number;
+export function clamp(n: any, min?: number, max?: number): any;
+export function clean(k: any, locase?: boolean): any;
+export function getdumpmacro(nodo: any): string;
+export function getnodebyid(id: any, nodocorrente: any): any;
+export function getprojectkeys(project: any): any;
+/**
+ * Calcola i punti di offset tra due percorsi
+ * Trova i punti del secondo percorso che corrispondono all'offset del primo
+ * @param {Array<{x:number,y:number}>} pt - Array di punti del primo percorso
+ * @param {Array<{x:number,y:number}>} pt2 - Array di punti del secondo percorso
+ * @param {number} delta - Distanza di offset
+ * @returns {Array<{x:number,y:number}>} Array di punti del percorso offset
+ */ export function getptsoffset(pt: Array<{
+    x: number;
+    y: number;
+}>, pt2: Array<{
+    x: number;
+    y: number;
+}>, delta: number): Array<{
+    x: number;
+    y: number;
+}>;
+/**
+ * Calcola le normali e i valori UV per un percorso chiuso.
+ * @param {Array<Object>} path - Array di punti {x,y}
+ * @param {number} [c=0] - Coefficiente c per il calcolo di z
+ * @param {number} [a=0] - Coefficiente a per il calcolo di z
+ * @param {number} [b=0] - Coefficiente b per il calcolo di z
+ * @param {number} [anglemin=30] - Angolo minimo in gradi per la suddivisione dei punti
+ * @returns {Array<Object>} Array di punti con normali e coordinate UV
+ */
+/**
+ * Crea un oggetto shape per manipolare forme 2D
+ * @returns {Object} Oggetto con metodi per manipolare la forma
+ * @property {string} key - Hash univoco della forma
+ * @property {Array<{x:number,y:number}>} pt - Array dei punti della forma
+ * @property {Array<number>} vec - Array dei punti come vettore [x1,y1,x2,y2,...]
+ * @property {number} orient - Orientamento della forma (1 orario, -1 antiorario, 0 degenere)
+ * @method clone() - Crea una copia della forma
+ * @method rotate(deg) - Ruota la forma di deg gradi
+ * @method move(x,y) - Sposta la forma di x,y
+ * @method fromclip(vv) - Inizializza da punti in formato clipper
+ * @method fromvec(aa) - Inizializza da array di coordinate [x1,y1,x2,y2,...]
+ * @method frompt(pts) - Inizializza da array di punti [{x,y},...]
+ * @method fromstr(str) - Inizializza da stringa con sintassi speciale
+ * @method addpt(pts) - Aggiunge punti alla forma
+ * @method addracc(v1,v2,suddivisioni,addv1v2) - Aggiunge raccordo tra punti
+ * @method setorient(mode) - Imposta l'orientamento della forma
+ * @method reverse() - Inverte l'ordine dei punti
+ * @method pointinshape(p) - Verifica se un punto è interno alla forma
+ * @method azzera() - Rimuove tutti i punti
+ * @method removeduplicate(delta) - Rimuove punti duplicati
+ * @method to3d(u0,c,a,b) - Converte in forma 3D con normali
+ */
+export function getshape(): any;
+export function getsubrules(nodocorrente: any): ({
+    id: string;
+    level: number;
+    name: string;
+    des?: undefined;
+    spec?: undefined;
+} | {
+    id: any;
+    name: any;
+    des: any;
+    spec: number;
+    level: number;
+})[];
+/**
+ * Esegue una semplice somma sincrona di due numeri
+ * @param {number} a - Primo numero da sommare
+ * @param {number} b - Secondo numero da sommare
+ * @returns {number} La somma dei due numeri
+ */ export function hash(obj: any): number;
+export function isfn(row: any): boolean;
+export function ismacro(row: any): any;
+/**
+ * Calcola il vettore normale unitario di un segmento di linea.
+ * @param {Object} p1 - Punto iniziale {x,y}
+ * @param {Object} p2 - Punto finale {x,y}
+ * @returns {Object} Vettore normale unitario {nx,ny}
+ */ export function normal2(p1: any, p2: any): any;
+/**
+ * Crea una curva di Bézier quadratica tra due segmenti di linea.
+ * @param {Object} a1 - Punto iniziale del primo segmento {x,y}
+ * @param {Object} a2 - Punto finale del primo segmento {x,y}
+ * @param {Object} b1 - Punto iniziale del secondo segmento {x,y}
+ * @param {Object} b2 - Punto finale del secondo segmento {x,y}
+ * @param {number} [subdivisions=10] - Numero di suddivisioni della curva
+ * @returns {Array<Object>} Array di punti {x,y} che formano la curva
+ */
+export function raccordabezier(a1: any, a2: any, b1: any, b2: any, subdivisions?: number): Array<any>;
+/**
+ * Crea un oggetto per operazioni booleane e manipolazione di forme 2D usando la libreria Clipper
+ * @returns {Object} Oggetto con metodi per operazioni su forme
+ * @property {Function} offset - Crea un offset della forma
+ * @property {Function} inflate - Espande o contrae una forma
+ * @property {Function} unisci - Unisce più forme con gestione di fori e tagli
+ */
+export function shapeclip(): any;
+export function valutagrafica(amb: any, startmacro: any, rulespec: any, progetto: any, fnreload: any): Promise<{
+    oo: any;
+    vari: any;
+    fnlist: any[];
+}>;
+declare function bordi(ff: any): {
+    bt: any;
+    bb: any;
+    bl: any;
+    br: any;
+};
+declare function creabordi(ff: any, shape: any, shape2: any): {
+    pt: any;
+    type: string;
+}[];
+/**
+* Genera segmenti basati su intervalli e punti di interruzione
+* @param {Array<{a: number, b: number}>} t1 - Array di oggetti che rappresentano intervalli con coordinate a e b
+* @param {Array<number>} [t2] - Array opzionale di punti di interruzione
+* @param {boolean} [interna=false] - Se true, usa i bordi interni degli intervalli
+* @param {boolean} [allbreak=false] - Se true, considera ogni punto degli intervalli come una rottura
+* @returns {Array<{a: number, b: number}>} Array di segmenti generati
+*/ declare function generatesegments(t1: Array<{
+    a: number;
+    b: number;
+}>, t2?: Array<number>, interna?: boolean, allbreak?: boolean): Array<{
+    a: number;
+    b: number;
+}>;
+declare function internalshape(ff: any, shape: any): any;
+declare function pushlineare(ff: any, type: any, des: any, l0: any, l1: any, id: number, shapecontorno: any, areas: any): {
+    id: number;
+    type: any;
+    des: any;
+    shape: any;
+    info: any;
+};
+declare function pushshape(ff: any, type: any, des: any, shape: any, info: any, id?: number): {
+    id: number;
+    type: any;
+    des: any;
+    shape: any;
+    info: any;
+};
+export { splitter as SP };

package/types/markcad3d.d.ts

@@ -0,0 +1,162 @@
+export const SIDE: any;
+/**
+ * Aggiunge un pivot a un oggetto 3D esistente, mantenendone posizione e orientamento globale.
+ * @param {THREE.Object3D} grp - Oggetto esistente già posizionato nella scena.
+ * @param {THREE.Vector3} pivotLocal - Punto (locale) attorno a cui ruotare (es: -x/2, -y/2, 0).
+ * @param {Object} movimento - Istanza della classe MovimentoBase o derivata.
+ * @returns {THREE.Group} - Nuovo gruppo contenitore con pivot.
+ */
+export function addmovpivot(gcad: any, grp: THREE.Object3D, movimento: any, op?: {}, x?: number, y?: number, z?: number): THREE.Group;
+export function creategroup(name: any): any;
+export function deletegroup(grpbase: any, name: any): void;
+export function edgesfromgeometry(g1: any, layer?: number): any;
+/**
+ * Crea una geometria estrusa con opzioni avanzate
+ * @param {string} orient - Orientamento dell'estrusione
+ * @param {number} hshape - Altezza dell'estrusione
+ * @param {Object} shape - Forma base
+ * @param {Array} holes - Array di fori
+ * @param {Array} mats - Array di materiali
+ * @param {Object} options - Opzioni di configurazione
+ * @returns {THREE.Group} Gruppo contenente la geometria estrusa
+ */ export function estruso(gcad: any, orient: string, hshape: number, shape: any, holes: any[], mats: any[], options: any): THREE.Group;
+/**
+ * Crea una geometria estrusa con opzioni avanzate
+ * @param {string} orient - Orientamento dell'estrusione
+ * @param {number} hshape - Altezza dell'estrusione
+ * @param {Object} shape - Forma base
+ * @param {Array} holes - Array di fori
+ * @param {Array} mats - Array di materiali
+ * @param {Object} options - Opzioni di configurazione
+ * @returns {THREE.Group} Gruppo contenente la geometria estrusa
+ */ export function estrusopat(gcad: any, orient: string, pat: any, shape: any, mats: any[], options: any): THREE.Group;
+export function get3dshape(punti: any, material: any, layer: any): any;
+export function getbox(gcad: any, x: any, y: any, z: any, mat: any, options: any): Promise<any>;
+/**
+ * Crea un cilindro 3D con orientamento personalizzabile
+ * @param {string} ori - Orientamento (X/L, Y/A, Z/P)
+ * @param {number} h - Altezza
+ * @param {number} r1 - Raggio base
+ * @param {number} r2 - Raggio top
+ * @param {THREE.Material|Array} mats - Materiale/i da applicare
+ * @param {Object} options - Opzioni di configurazione
+ * @returns {Promise<THREE.Group>} Gruppo contenente il cilindro
+ */
+export function getcilindro(gcad: any, ori: string, h: number, r1: number, r2: number, mats: THREE.Material | any[], options: any): Promise<THREE.Group>;
+/**
+ * Crea un box 3D con linee di bordo opzionali
+ * @param {number} x - Larghezza
+ * @param {number} y - Altezza
+ * @param {number} z - Profondità
+ * @param {THREE.Material} mat - Materiale da applicare
+ * @param {Object} options - Opzioni di configurazione
+ * @returns {Promise<THREE.Group>} Gruppo contenente il box
+ */ export function getface(gcad: any, x: number, y: number, mat: THREE.Material, scaled?: boolean): Promise<THREE.Group>;
+/**
+ * Crea una linea 3D
+ * @param {Object} l - Oggetto contenente punti p1 e p2
+ * @param {string} id - Identificatore
+ * @param {THREE.Material} [mat=null] - Materiale da applicare
+ * @returns {THREE.Line} Linea 3D
+ */ export function getline(l: any, id: string, mat?: THREE.Material): THREE.Line;
+export function getlinesgeom(edges: any, layer?: number): any;
+export function getmesh(geom: any, material: any, layer?: number, clone?: boolean): any;
+/**
+ * Crea un gestore di movimento per animare oggetti 3D.
+ * @param {string} key - Chiave identificativa del movimento
+ * @param {Array<Object>} gtimeline - Timeline di passi di animazione. Ogni passo può contenere:
+ *   @param {number} time - Durata del passo in millisecondi
+ *   @param {(number|function)} [x] - Traslazione X (unità o funzione che restituisce unità)
+ *   @param {(number|function)} [y] - Traslazione Y
+ *   @param {(number|function)} [z] - Traslazione Z
+ *   @param {(number|function)} [s] - Scala uniforme (moltiplicatore)
+ *   @param {(number|function)} [sx] - Scala X
+ *   @param {(number|function)} [sy] - Scala Y
+ *   @param {(number|function)} [sz] - Scala Z
+ *   @param {(number|function)} [ax] - Rotazione X (in giri)
+ *   @param {(number|function)} [ay] - Rotazione Y
+ *   @param {(number|function)} [az] - Rotazione Z
+ *   @param {(number|function)} [t] - Trasparenza (0-1)
+ * @returns {Object} Oggetto gestore del movimento con metodi:
+ *   @property {number} tline - Durata totale della timeline
+ *   @property {function} clear - Pulisce la timeline
+ *   @property {function} add - Aggiunge un passo alla timeline
+ *   @property {string} key - Chiave del movimento
+ *   @property {function} step - Esegue un passo dell'animazione
+ *   @property {function} reset - Resetta l'oggetto alla posizione iniziale
+ */ export function getmovimento(key: string, gtimeline?: Array<any>): any;
+export function getpannello(gcad: any, orientamento: any, x: any, y: any, z: any, mat1: any, mat2: any, options: any): Promise<any>;
+/**
+ * Crea un punto 3D rappresentato da una sfera
+ * @param {Object} p - Coordinate del punto
+ * @param {string} id - Identificatore
+ * @param {THREE.Material} [mat=null] - Materiale da applicare
+ * @param {number} [size=5] - Dimensione della sfera
+ * @returns {THREE.Mesh} Punto 3D
+ */ export function getpoint(p: any, id: string, mat?: THREE.Material, size?: number): THREE.Mesh;
+export function getpunto(gcad: any, x: any, y: any, z: any, color: string, options: any): Promise<any>;
+/**
+ * Crea una quota tra due punti in 3D sul piano XY
+ * @param {string} testo - Testo da visualizzare nella quota
+ * @param {number} x1 - Coordinata X del primo punto
+ * @param {number} y1 - Coordinata Y del primo punto
+ * @param {number} x2 - Coordinata X del secondo punto
+ * @param {number} y2 - Coordinata Y del secondo punto
+ * @param {number} sizetesto - Dimensione del testo
+ * @param {Object} options - Opzioni aggiuntive
+ * @returns {THREE.Group} Gruppo contenente la quota
+ */ export function getquota(gcad: any, testo: string, x1: number, y1: number, x2: number, y2: number, altezza?: number, offset?: number, options?: any): THREE.Group;
+/**
+ * Crea un punto di riferimento invisibile nell'albero 3D
+ * @param {number} x - Coordinata X
+ * @param {number} y - Coordinata Y
+ * @param {number} z - Coordinata Z
+ * @param {Object} dati - Dati da archiviare nell'oggetto
+ * @param {string} [id=null] - Identificatore opzionale
+ * @returns {THREE.Object3D} Oggetto di riferimento invisibile
+ */
+export function getriferimento(dati: any, x?: number, y?: number, z?: number, id?: string): THREE.Object3D;
+export function getsprite(gcad: any, x: any, y: any, z: any, mat: any, options?: {}): Promise<any>;
+/**
+ * Crea una targhetta rettangolare con testo
+ * @param {Array|string} testo - Array di oggetti {testo, size, colore} o stringa
+ * @param {number} dim - Larghezza/altezza della targhetta
+ * @param {Object} options - Opzioni aggiuntive
+ * @returns {THREE.Mesh} Mesh con la targhetta
+ */ export function gettarghetta(gcad: any, testo: any[] | string, dim?: number, options?: any): THREE.Mesh;
+export function groupfromgeometry(geometry: any, material: any, x: any, y: any, z: any, name: any, layer: any): any;
+export function infoestrudi(shape: any, hshape: any, pts: any, options: any): {
+    aini: any;
+    aini2: any;
+    afin: any;
+    afin2: any;
+    pts: any;
+    mi: any;
+    ma: any;
+    rect: {
+        x: any;
+        y: any;
+    }[];
+    dimx: number;
+    dimy: number;
+    lnom: number;
+    lmax: number;
+    lmin: number;
+    lmed: number;
+};
+export let materialline1: any;
+export let materialline2: any;
+export const mblack: any;
+export const mblue: any;
+export const mgray1: any;
+export const mgray2: any;
+export const mgreen: any;
+export const mred: any;
+declare const mwhite$1: any;
+export function posiziona(grp: any, pos?: {}): any;
+export function randombasemat(): any;
+export function revolve(gcad: any, shape: any, orient: any, mat: any, options: any): any;
+export const scaleunit: 0.001;
+export function spritemat(gcad: any, file: any): Promise<any>;
+export function svuotanodo(n: any): void;
+export { mwhite$1 as mwhite };

package/types/marked.d.ts

@@ -0,0 +1,71 @@
+export class Render {
+    constructor(baseurl: any, easy: any, callback: any);
+    baseurl: any;
+    easy: any;
+    callback: any;
+    code(code: any, lang: any, codes: any): string;
+    blockquote(quote: any): any;
+    html(html: any): any;
+    heading(text: any, level: any, raw: any): string;
+    hr(): "" | "<div class=\"my-4\"><hr/></div>";
+    list(body: any, ordered: any): string;
+    listtitle(body: any): string;
+    listitem(text: any, num: any): string;
+    paragraph(text: any): any;
+    table(header: any, body: any): string;
+    tablerow(content: any): string;
+    tablecell(content: any, header: any, align: any): string;
+    colorbase(text: any): string;
+    formula(text: any, full?: boolean): string;
+    coloralt(text: any): string;
+    blink(text: any): void;
+    strong(text: any): string;
+    ico(text: any): string;
+    em(text: any): string;
+    codespan(text: any): string;
+    br(): string;
+    del(text: any): string;
+    link(href: any, title: any, text: any): string;
+    image(href: any, title: any, text: any): string;
+    text(text: any): any;
+}
+export const aliasInfo: {
+    alias: any;
+    check(): void;
+    retoalias: {};
+    regex: Set<any>;
+    add(sigla: any, valore: any): any;
+    removeAll(): any;
+    setmappa(mappa: any): void;
+    parse(data: any, info: any, mappa: any): {
+        comments: any[];
+        info: boolean;
+    };
+};
+export function elang(str: any, lang: any, punct: any, codes: any): string;
+export function escapeHTML(str: any): any;
+export function formatrule(code: any): string;
+export function formatvariante(str: any): string;
+export function mark(xx: any, baseurl: any, notitle: boolean, parsedlist: boolean, callback: any): any;
+export function markeasy(xx: any, maxlen?: number, notitle?: boolean): any;
+export function markunoFormatCodeMirror(CodeMirror: any): void;
+export function parseinfomd(data: any, info: any, mappa: any): {
+    comments: any[];
+    info: boolean;
+};
+export function parselist(text: any, title?: string): {
+    txt: string;
+    cards: {
+        title: any;
+        lev: any;
+        data: any;
+    }[];
+    tm: any[];
+};
+export function parserule(tt: any): any[];
+export function parsetext(tt: any): any[];
+declare function tokenparser(res: any, render: any, maxlen?: number): any;
+export function parsevars(v: any, vars: any): any;
+export function tokenize(src: any, easylen: any, noheader?: boolean): any;
+export function unescapeHTML(str: any): any;
+export { tokenparser as parsetokens };

package/types/markuno.d.ts

@@ -0,0 +1,552 @@
+export class Ambiente {
+    constructor(cat?: string, maxdelays?: number, righevuote?: boolean);
+    righevuote: boolean;
+    maxdelays: number;
+    setcatalog(cat: any): any;
+    cat: any;
+    item: any;
+    rule: any;
+    model: any;
+    get muvalutatore(): {
+        getcolonne: typeof getcolonne;
+        muCalc: typeof muCalc;
+        muEval: typeof muEval;
+        tipifree: string[];
+    };
+    azzera(mode?: boolean): void;
+    /** @type {Variabile} */
+    vari: Variabile;
+    ruleheader: string;
+    /** @type {Object.<string, Macro>} */
+    macro: {};
+    /** @type {Object.<string, Variante>} */
+    varianti: {};
+    varelenco: {};
+    macroelenco: {};
+    scripts: {};
+    setfndot(fndotcallback: any): Promise<void>;
+    fndotcallback: any;
+    parseheaderfrominfo(tm: any): void;
+    setitem(item: any, rule: any, model: any, datadelgiorno: any): void;
+    data: any;
+    getheader(cod: any): Promise<any>;
+    getalias(): Promise<any>;
+    get deriva(): any;
+    getmacro(riga: any): Promise<{
+        macro: any;
+        pars: string[];
+    } | {
+        macro?: undefined;
+        pars?: undefined;
+    }>;
+    getvariante(cod: any): Promise<any>;
+    varcompila(v: any, callback: any): Promise<void>;
+    macrocompila(v: any, callback: any): Promise<void>;
+    barrecompila(articolibarre: any, titolibarre: any, callback: any): Promise<CodiceBarra>;
+    tojson(d: any): Promise<any>;
+    compila(info: any, callback: any): Promise<void>;
+    getheaderfromdb(name: any): Promise<{
+        head: any;
+        rows: any;
+        macros: any;
+    }>;
+    getlinkedmacros(rule: any, macros: any): Promise<void>;
+    setruleheader(rule: any, pars: any): Promise<any>;
+    getruleheader(): any;
+    setvariante(cod: any, opz: any): Promise<any>;
+    valuta(codice: any): Promise<any>;
+    setinfos(tm: any): void;
+    #private;
+}
+export class CodiceBarra {
+    barre: {};
+    azzera(): void;
+    oriented(t: any, l: any, a: any, p: any): {
+        t: string;
+        x: any;
+        y?: undefined;
+        z?: undefined;
+    } | {
+        t: any;
+        x: any;
+        y: any;
+        z: any;
+    };
+    getcode(codicebarratot: any, l: any, a: any, p: any, callback: any): Promise<any>;
+    compila(vettore: any, headers: any): void;
+}
+export class Macro {
+    constructor(amb: any, name: any);
+    name: any;
+    cat: string;
+    /** @type {Ambiente} */
+    amb: any;
+    azzera(): void;
+    key: string;
+    localvar: {};
+    head: any[] | {
+        cod: any;
+        t: string;
+    }[];
+    frontend: boolean;
+    valid: any[];
+    parametri: {};
+    paralias: {};
+    formula: {};
+    settings: {};
+    errori: any[];
+    codice: any;
+    genera: {};
+    get isgenera(): number;
+    get iscodice(): any;
+    get isheader(): number;
+    geterrori(): any[];
+    getparametri(): {};
+    setparametri(pars: any): Promise<{}>;
+    setparametro(name: any, value: any, propaga?: boolean): Promise<any>;
+    impostaparametri(parimposta: any, parcall: any, ismacro?: boolean): Promise<void>;
+    checkvalid(formula: any): Promise<boolean>;
+    getmacrostr(): string;
+    getmacro(): any;
+    setmacro(vv: any): void;
+    load(xname: any, xcat: any): Promise<boolean>;
+    loadAndCompile(file: any, cat: any, acapo?: boolean): Promise<any>;
+    parsedata(res: any, acapo?: boolean): Promise<void>;
+    cleanfiltraparametri(key: any, codice: any, acapo: any): any[];
+    #private;
+}
+export class Variabile {
+    static isValidKey(key: any): boolean;
+    static sanitizeKey(key: any): any;
+    dictionary: {};
+    vec: any[];
+    counter: number;
+    setfndot(fndotcallback: any): void;
+    fndotcallback: any;
+    /**
+         * Salva lo stato corrente delle variabili nello stack
+         */ push(): void;
+    /**
+         * Ripristina l'ultimo stato salvato delle variabili
+         */ pop(): void;
+    /**
+         * Rimuove tutte le variabili e pulisce lo stack
+         */ clear(): void;
+    azzera: () => void;
+    var(key: any): any;
+    getvar(key: any): any;
+    colonna(value: any, index: any): any;
+    /**
+         * Restituisce un dump delle variabili
+         */ dump(isstr?: boolean): string[] | {
+        cod: string;
+        val: any;
+    }[];
+    /**
+         * Aggiunge o rimuove una variabile
+         */ add(key: any, value: any): void;
+    /**
+         * Valuta un'espressione con supporto per callback asincroni
+         */ valutasync(str: any): any;
+    valuta(ex: any, callback: any): Promise<any>;
+    parametrokeyval(p: any): Promise<{
+        k?: undefined;
+        v?: undefined;
+    } | {
+        k: any;
+        v: any;
+    }>;
+}
+/**
+ * Classe per gestire le varianti di un prodotto.
+ * Permette di caricare, manipolare e convertire varianti di prodotto con relativi attributi e limiti.
+ * @class
+ * @exports
+ */ export class Variante {
+    /**
+         * Crea una nuova istanza di Variante
+         * @param {Object} amb - Ambiente di esecuzione contenente il contesto applicativo
+         */
+    constructor(amb: any);
+    rows: {};
+    name: string;
+    key: string;
+    /** @type {Ambiente} */
+    amb: any;
+    /**
+         * Imposta i dati principali della variante
+         * @param {string} id - Identificativo univoco della variante
+         * @param {string} cat - Categoria di appartenenza
+         * @returns {Object} Oggetto contenente nome e categoria normalizzati
+         */ setheader(id: string, cat: string): any;
+    cat: string;
+    alias: string;
+    obbligo: boolean;
+    des: any;
+    vdef: any[] | string[];
+    h: any[] | {
+        des: string;
+    }[];
+    /**
+         * Cerca la riga con dimensione più vicina a quella richiesta
+         * @param {number|string} dim - Dimensione target da cercare
+         * @param {number} colonna - Indice della colonna (1-based) contenente la dimensione
+         * @returns {string} Riga formattata nel formato CSV
+         */ fromdim(dim: number | string, colonna?: number): string;
+    /**
+         * Carica una variante dal database o da file
+         * @param {string} id - Identificativo della variante
+         * @param {string} cat - Categoria della variante
+         * @param {boolean} nofilter - Se true, non carica i filtri associati
+         * @returns {Promise<boolean>} Promise che risolve a true se il caricamento ha successo
+         */ load(id: string, cat: string, nofilter?: boolean): Promise<boolean>;
+    limits: {}[] | {
+        v: any[];
+        datai: number;
+        dataf: number;
+    }[];
+    /**
+         * Carica il contenuto della variante da array di stringhe
+         * @private
+         * @param {string[]} lines - Array di stringhe contenenti la definizione della variante
+         * @returns {Promise<boolean>} Promise che risolve a true se il caricamento ha successo
+         */ private _loadContent;
+    noerp: boolean;
+    /**
+         * Converte la variante in un vettore di righe
+         * @returns {string[]} Array di righe formattate
+         */ tovec(): string[];
+    /**
+         * Converte un codice nella sua rappresentazione CSV
+         * @param {string} cod - Codice da convertire
+         * @returns {string} Stringa CSV o codice originale se non trovato
+         */ tovar(cod: string, vcod?: string): string;
+    /**
+         * Verifica se un'opzione è valida
+         * @param {string} opz - Opzione da verificare
+         * @returns {boolean} True se l'opzione è valida
+         */ isvalidopz(opz: string): boolean;
+    /**
+         * Trova la prima opzione valida tra quelle disponibili
+         * @param {string} opz - Opzione da controllare per prima
+         * @returns {string|undefined} Prima opzione valida trovata o undefined
+         */ firstvalid(opz: string): string | undefined;
+    /**
+         * Resetta tutti i filtri applicati alla variante
+         */ resetfilter(): void;
+    /**
+         * Restituisce le chiavi valide ordinate alfabeticamente
+         * @returns {string[]} Array di chiavi valide
+         */ validkeys(): string[];
+    limitfiltra(filtra: any): void;
+    /**
+         * Applica i limiti configurati alle opzioni della variante
+         * @returns {Array|void} Array di limiti applicati o void se reset
+         */ limita(filtra: any): any[] | void;
+    /**
+         * Carica il contenuto esteso della variante
+         * @param {Object|string} content - Contenuto da caricare, può essere un oggetto o una stringa
+         * @returns {Promise<void>} Promise che si risolve al completamento del caricamento
+         */ loadContentExtended(content: any | string): Promise<void>;
+    todata(): {
+        name: string;
+        des: any;
+        alias: string;
+        obbligo: boolean;
+        h: any[] | {
+            des: string;
+        }[];
+        rows: {};
+        limits: {}[] | {
+            v: any[];
+            datai: number;
+            dataf: number;
+        }[];
+        key: string;
+    };
+    #private;
+}
+/**
+ * Valida e separa un identificatore e una categoria
+ * @param {string} id - Identificatore da validare (formato: "categoria/nome" o solo "nome")
+ * @param {string} cat - Categoria di default
+ * @throws {Error} Se manca la categoria
+ * @returns {{name: string, cat: string}} Oggetto con nome e categoria validati
+ */ export function checkmu(id: string, cat: string): {
+    name: string;
+    cat: string;
+};
+/**
+ * Valida un identificatore verificando che contenga solo caratteri permessi
+ * @param {string} id - Identificatore da validare
+ * @throws {Error} Se l'identificatore contiene caratteri non validi
+ * @returns {string} Identificatore validato in minuscolo
+ */ export function checkname(id: string): string;
+export function clamp(n: any, min?: number, max?: number): any;
+export function clean(k: any, locase?: boolean): any;
+export function dammivariante(amb: any, macro: any, ky: any): Promise<any>;
+export const errori: {
+    /**
+         * Azzera la lista degli errori
+         */ azzera(): void;
+    err: any[];
+    /**
+         * Aggiunge un errore alla lista
+         * @param {string} msg - Messaggio di errore
+         * @param {Object} row - Informazioni aggiuntive sull'errore
+         */ add(msg: string, row: any): void;
+    /**
+         * Restituisce la lista completa degli errori
+         * @returns {Array} Lista degli errori
+         */ get(): any[];
+    /**
+         * Restituisce il numero di errori presenti
+         * @returns {number} Numero di errori
+         */ readonly length: number;
+    /**
+         * Converte la lista degli errori in stringa
+         * @returns {string} Rappresentazione testuale degli errori
+         */ toString(): string;
+};
+/**
+ * Converte una stringa in un oggetto JSON, gestendo errori e restituendo un valore di default se non valido
+ * @param {string|Array|Object} str - Stringa da convertire in JSON, array o oggetto da restituire direttamente
+ * @param {*} [def={}] - Valore di default da restituire in caso di errore di parsing
+ * @throws {Error} Non genera eccezioni, gli errori vengono loggati internamente
+ * @returns {*} L'oggetto JSON convertito dalla stringa, l'input originale se è un array/oggetto, o il valore di default in caso di errore
+ * @example
+ * fromjson('{"a": 1}') // returns {a: 1}
+ * fromjson([1,2,3]) // returns [1,2,3]
+ * fromjson('invalid json', {}) // returns {}
+ */ export function fromjson(str: string | any[] | any, def?: any): any;
+/**
+ * Estrae le proprietà non-funzione da un oggetto, escludendo chiavi specificate
+ * @param {Object} obj - Oggetto da cui estrarre le proprietà
+ * @param {string[]} [exclude] - Array di chiavi da escludere
+ * @returns {Object} Nuovo oggetto con le proprietà estratte
+ */ export function getOggetto(obj: any, exclude?: string[]): any;
+/**
+ * Converte una stringa in array di colonne, gestendo diversi formati
+ * @param {string} value - Stringa da convertire
+ * @returns {string[]} Array di colonne
+ */ export function getcolonne(value: string, keepquote?: boolean): string[];
+/**
+ * Analizza una stringa per estrarre una coppia chiave-valore
+ * @param {string} r - Stringa da analizzare (es: "chiave=valore")
+ * @param {string} [sep='='] - Carattere separatore
+ * @returns {{v: string, o: string, fl: boolean}} Oggetto contenente chiave (v), valore (o) e flag presenza separatore (fl)
+ */ export function getcouple(r: string, sep?: string, locase?: boolean): {
+    v: string;
+    o: string;
+    fl: boolean;
+};
+/**
+ * Formatta un messaggio di errore rimuovendo informazioni non necessarie
+ * @param {Error|string} err - L'errore da formattare
+ * @returns {string} Il messaggio di errore formattato
+ */ export function geterrdes(err: Error | string): string;
+export function getheaddims(dims: any): any;
+export function gettipocolonna(cod: any): string;
+export function gettipofolder(cod: any): string;
+export function hash(obj: any): string;
+export function impostavariante(amb: any, macro: any, a: any, b: any, head: any): Promise<any>;
+export function intvaluta(amb: any, mac: any, str: any): Promise<any>;
+export function muInit(cat: any, cbGetMacro: any, cbGetVariante: any, cbFunc: any, cbInfo: any, cbGetFile: any, cbLogga: any): Ambiente;
+/**
+ * Funzione di logging che utilizza un callback personalizzato se disponibile
+ * @param {...any} args - Argomenti da loggare
+ */ export function logga(...args: any[]): void;
+/**
+ * Valuta un'espressione matematica o logica e restituisce il risultato
+ * @param {string|number} expression - L'espressione da valutare
+ * @returns {number} Il risultato della valutazione dell'espressione
+ * @description
+ * Supporta operazioni matematiche di base, funzioni trigonometriche,
+ * operatori di confronto e operazioni logiche.
+ * Le funzioni supportate includono: sqrt, floor, abs, sin, cos, random, clamp, round
+ */ export function muCalc(expression: string | number): number;
+/**
+ * Rimuove i commenti dal codice sorgente mantenendo la struttura del codice
+ * @param {string} codice - Il codice sorgente da processare
+ * @param {boolean} tienivuoti - Se true mantiene le righe vuote
+ * @returns {string[]} Array di righe di codice senza commenti
+ */ export function muClComments(codice: string, tienivuoti: boolean): string[];
+/**
+ * Analizza e organizza il codice in una struttura dati gerarchica
+ * @param {string[]} tt - Array di righe di codice da analizzare
+ * @param {boolean} acapo - Se true mantiene i ritorni a capo nel contenuto
+ * @returns {Object[]} Array di oggetti rappresentanti la struttura del codice
+ * @throws {Error} Se tt non è un array
+ */ export function muClean(tt: string[], acapo?: boolean): any[];
+export function muCompileScript(codice: any): any;
+export function muEval(amb: any, mac: any, codice: any, options: any): any;
+export function muEvalScript(amb: Ambiente, codice: any, pars: any, reset?: boolean): Promise<{
+    output: any;
+    vari: {};
+    errori: {
+        /**
+             * Azzera la lista degli errori
+             */ azzera(): void;
+        err: any[];
+        /**
+             * Aggiunge un errore alla lista
+             * @param {string} msg - Messaggio di errore
+             * @param {Object} row - Informazioni aggiuntive sull'errore
+             */ add(msg: string, row: any): void;
+        /**
+             * Restituisce la lista completa degli errori
+             * @returns {Array} Lista degli errori
+             */ get(): any[];
+        /**
+             * Restituisce il numero di errori presenti
+             * @returns {number} Numero di errori
+             */ readonly length: number;
+        /**
+             * Converte la lista degli errori in stringa
+             * @returns {string} Rappresentazione testuale degli errori
+             */ toString(): string;
+    };
+}>;
+export function muGenerate(macro: any, amb: any, genera: any, callback: any, isTestmode?: number): Promise<boolean>;
+/**
+ * Analizza e processa i limiti definiti nel codice
+ * @param {string} dati - Dati contenenti le definizioni dei limiti
+ * @returns {Object[]} Array di oggetti rappresentanti i limiti processati
+ */ export function muLimits(dati: string): any[];
+/**
+ * Analizza il codice sorgente e restituisce un array di token con classi CSS
+ * @param {string} tt - Il codice sorgente da analizzare
+ * @param {boolean} isvar - Flag che indica se analizzare come variabile
+ * @returns {Array<{class: string, text: string}>} Array di token con classi CSS
+ */ export function muParsecode(tt: string, isvar: boolean): Array<{
+    class: string;
+    text: string;
+}>;
+export function muValuta(mu: any, codice: any, azzera: any): any;
+export namespace mustr {
+    namespace mus {
+        namespace variants {
+            let cod: string;
+            let des: string;
+            let alias: string;
+            let info: string;
+            let md: string;
+            let __pk: string;
+        }
+        namespace extras {
+            export let tipo: string;
+            let cod_1: string;
+            export { cod_1 as cod };
+            let info_1: string;
+            export { info_1 as info };
+            let __pk_1: string;
+            export { __pk_1 as __pk };
+        }
+        namespace macros {
+            let cod_2: string;
+            export { cod_2 as cod };
+            let des_1: string;
+            export { des_1 as des };
+            let info_2: string;
+            export { info_2 as info };
+            let md_1: string;
+            export { md_1 as md };
+            export let def: string;
+            export let isgenera: string;
+            export let iscodice: string;
+            export let isheader: string;
+            let __pk_2: string;
+            export { __pk_2 as __pk };
+        }
+        namespace infos {
+            let cod_3: string;
+            export { cod_3 as cod };
+            let des_2: string;
+            export { des_2 as des };
+            let info_3: string;
+            export { info_3 as info };
+            let __pk_3: string;
+            export { __pk_3 as __pk };
+        }
+        namespace barcodes {
+            let cod_4: string;
+            export { cod_4 as cod };
+            let des_3: string;
+            export { des_3 as des };
+            let info_4: string;
+            export { info_4 as info };
+            let __pk_4: string;
+            export { __pk_4 as __pk };
+        }
+    }
+}
+export function newAmbiente(cat: any, maxmillis?: number): Ambiente;
+export function newMacro(amb: any, name: any): Macro;
+export function newVariabile(): Variabile;
+export function newVariante(cod: any, cat: any, amb: any): Promise<Variante>;
+export function parselimitifromdb(rr: any): {}[];
+export function parselimitifromrule(limvec: any): {
+    v: any[];
+    datai: number;
+    dataf: number;
+}[];
+/**
+ * Analizza variabili in un'espressione usando delimitatori
+ * @param {string} ex - Espressione da analizzare
+ * @param {number} k0 - Posizione iniziale
+ * @param {string} inipar - Delimitatore iniziale ([, (, {)
+ * @param {string} endpar - Delimitatore finale (], ), })
+ * @param {boolean} [nonewline=false] - Se true, termina all'incontro di un newline
+ * @returns {{i: number, res: string[]}} Risultato dell'analisi con posizione finale e array risultati
+ */ export function parsevar(ex: string, k0: number, inipar: string, endpar: string, nonewline?: boolean): {
+    i: number;
+    res: string[];
+};
+export function poppars(amb: any, tm: any): Promise<void>;
+export function pushpars(amb: any, macro: any, parsfunzione: any, parsinit: any): Promise<{
+    v: string;
+    o: any;
+}[]>;
+export function quote(v: any): any;
+/**
+ * Classe per la gestione degli errori con funzionalità di accumulo e formattazione
+ */
+/**
+ * Copia le proprietà non-funzione da un oggetto sorgente a uno destinazione
+ * @param {Object} objDestinazione - Oggetto destinazione
+ * @param {Object} objSorgente - Oggetto sorgente
+ */
+export function setOggetto(objDestinazione: any, objSorgente: any): void;
+/**
+ * Esegue una semplice somma sincrona di due numeri
+ * @param {number} a - Primo numero da sommare
+ * @param {number} b - Secondo numero da sommare
+ * @returns {number} La somma dei due numeri
+ */
+export function testsync(a: number, b: number): number;
+export const tipicolonna: ({
+    cod: string;
+    des: string;
+    folder?: undefined;
+} | {
+    cod: string;
+    des: string;
+    folder: string;
+})[];
+export const tipifree: string[];
+export const tipiheader: {
+    cod: string;
+    des: string;
+}[];
+/**
+ * Restituisce il timestamp corrente in millisecondi
+ * @returns {number} Timestamp corrente
+ */ export function tk(): number;
+export function toCadPars(str: any): {};
+export function toJson(t: any): string;
+export function tonum(s: any, dec?: number): number;
+/**
+ * Restituisce il timestamp corrente in millisecondi
+ * @returns {number} Timestamp corrente
+ */ export function xdt(): number;
+export { muInit as jsTest };