markuno_lib 1.1.26 → 1.1.28

package/types/markcad.d.ts

@@ -0,0 +1,413 @@
+/**
+ * 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;
+/**
+ * Classe per la gestione degli errori con funzionalità di accumulo e formattazione
+ */ 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,70 @@
+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;
+    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 };