jtlt 0.1.0

package/dist/StringJoiningTransformer.d.ts

@@ -0,0 +1,168 @@
+export default StringJoiningTransformer;
+/**
+ *
+ */
+/**
+ * Joining transformer that builds a string result.
+ *
+ * This transformer provides a fluent API to compose strings while supporting
+ * object/array-building semantics similar to template languages. Most methods
+ * funnel through append(), which is state-aware:
+ *
+ * - Inside object(): values go to object properties via propOnly()/propValue().
+ * - Inside array(): values are pushed to the current array.
+ * - Otherwise: values are concatenated into the internal string buffer.
+ *
+ * Escaping rules:
+ * - text(): escapes HTML special chars (& and <) and will close an open tag.
+ * - string(): no HTML escaping or JSON stringification; context-aware.
+ * - plainText(): raw append to the top-level string buffer (bypasses state).
+ * - rawAppend(): like plainText() but documented as lower-level.
+ *
+ * HTML/XML helpers:
+ * - element() and attribute() allow building tags with optional auto-escaping
+ *   for attribute values unless cfg.preEscapedAttributes is set.
+ *
+ * Configuration hints (see joiningConfig in JTLT):
+ * - cfg.xmlElements: switch element() serializer to XML mode (self-closing,
+ *   name mapping rules differ, etc.).
+ * - cfg.preEscapedAttributes: skip escaping attribute values.
+ * - cfg.JHTMLForJSON / cfg.mode: affect how object()/array() serialize.
+ */
+declare class StringJoiningTransformer extends AbstractJoiningTransformer {
+    /**
+     * @param {string} s - Initial string
+     * @param {object} cfg - Configuration object
+     */
+    constructor(s: string, cfg: object);
+    _str: string;
+    /** @type {any} */
+    _objPropTemp: any;
+    /** @type {boolean | undefined} */
+    propOnlyState: boolean | undefined;
+    /** @type {boolean | undefined} */
+    _arrItemState: boolean | undefined;
+    /** @type {boolean | undefined} */
+    _objPropState: boolean | undefined;
+    /** @type {any} */
+    _obj: any;
+    /** @type {any[]} */
+    _arr: any[];
+    /** @type {string | undefined} */
+    _strTemp: string | undefined;
+    /** @type {Record<string, any>} */
+    propertySets: Record<string, any>;
+    /**
+     * @param {string|*} s - String or value to append
+     * @returns {StringJoiningTransformer}
+     */
+    append(s: string | any): StringJoiningTransformer;
+    /**
+     * @returns {string}
+     */
+    get(): string;
+    /**
+     * @param {string} prop - Property name
+     * @param {*} val - Property value
+     * @returns {StringJoiningTransformer}
+     */
+    propValue(prop: string, val: any): StringJoiningTransformer;
+    /**
+     * @param {string} prop - Property name
+     * @param {Function} cb - Callback function
+     * @returns {StringJoiningTransformer}
+     */
+    propOnly(prop: string, cb: Function): StringJoiningTransformer;
+    /**
+     * @param {object|Element} obj - Object to serialize
+     * @param {Function} cb - Callback function
+     * @param {any[]} [usePropertySets] - Property sets to use
+     * @param {object} [propSets] - Additional property sets
+     * @returns {StringJoiningTransformer}
+     */
+    object(obj: object | Element, cb: Function, usePropertySets?: any[], propSets?: object): StringJoiningTransformer;
+    /**
+     * @param {any[]|Element} [arr] - Array to serialize
+     * @param {Function} [cb] - Callback function
+     * @returns {StringJoiningTransformer}
+     */
+    array(arr?: any[] | Element, cb?: Function): StringJoiningTransformer;
+    /**
+     * @param {string|Element|object} str - String value or element
+     * @param {Function} [cb] - Callback function
+     * @returns {StringJoiningTransformer}
+     */
+    string(str: string | Element | object, cb?: Function): StringJoiningTransformer;
+    /**
+     * @param {number|Element|object} num - Number value or element
+     * @returns {StringJoiningTransformer}
+     */
+    number(num: number | Element | object): StringJoiningTransformer;
+    /**
+     * @param {boolean|Element|object} bool - Boolean value or element
+     * @returns {StringJoiningTransformer}
+     */
+    boolean(bool: boolean | Element | object): StringJoiningTransformer;
+    /**
+     * @returns {StringJoiningTransformer}
+     */
+    null(): StringJoiningTransformer;
+    /**
+     * @returns {StringJoiningTransformer}
+     */
+    undefined(): StringJoiningTransformer;
+    /**
+     * @param {number|Element} num - Non-finite number (NaN, Infinity, -Infinity)
+     * @returns {StringJoiningTransformer}
+     */
+    nonfiniteNumber(num: number | Element): StringJoiningTransformer;
+    /**
+     * @param {Function|Element} func - Function to stringify
+     * @returns {StringJoiningTransformer}
+     */
+    function(func: Function | Element): StringJoiningTransformer;
+    /**
+     * @param {string|object} elName - Element name or element object
+     * @param {object} [atts] - Element attributes
+     * @param {any[]} [childNodes] - Child nodes
+     * @param {Function} [cb] - Callback function
+     * @returns {StringJoiningTransformer}
+     */
+    element(elName: string | object, atts?: object, childNodes?: any[], cb?: Function): StringJoiningTransformer;
+    _openTagState: any;
+    /**
+     * @param {string} name - Attribute name
+     * @param {string|object} val - Attribute value
+     * @param {boolean} [avoidAttEscape] - Whether to avoid escaping the
+     *   attribute value
+     * @returns {StringJoiningTransformer}
+     */
+    attribute(name: string, val: string | object, avoidAttEscape?: boolean): StringJoiningTransformer;
+    /**
+     * @param {string} txt - Text content to escape and append
+     * @returns {StringJoiningTransformer}
+     */
+    text(txt: string): StringJoiningTransformer;
+    /**
+    * Unlike text(), does not escape for HTML; unlike string(), does not perform
+    *   JSON stringification; unlike append(), does not do other checks (but still
+    *   varies in its role across transformers).
+    * @param {string} str
+    * @returns {StringJoiningTransformer}
+    */
+    rawAppend(str: string): StringJoiningTransformer;
+    /**
+     * @param {string} str - Plain text to append without escaping
+     * @returns {StringJoiningTransformer}
+     */
+    plainText(str: string): StringJoiningTransformer;
+    /**
+     * Helper method to use property sets.
+     * @param {object} obj - Object to apply property set to
+     * @param {string} psName - Property set name
+     * @returns {object}
+     */
+    _usePropertySets(obj: object, psName: string): object;
+}
+import AbstractJoiningTransformer from './AbstractJoiningTransformer.js';
+//# sourceMappingURL=StringJoiningTransformer.d.ts.map

package/dist/StringJoiningTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/StringJoiningTransformer.js"],"names":[],"mappings":";AAuBA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IACE;;;OAGG;IACH,eAHW,MAAM,OACN,MAAM,EAsBhB;IAjBC,aAAmB;IACnB,kBAAkB;IAClB,cADW,GAAG,CACe;IAC7B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kBAAkB;IAClB,MADW,GAAG,CACO;IACrB,oBAAoB;IACpB,MADW,GAAG,EAAE,CACF;IACd,iCAAiC;IACjC,UADW,MAAM,GAAG,SAAS,CACJ;IACzB,kCAAkC;IAClC,cADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACR;IAGxB;;;OAGG;IACH,UAHW,MAAM,GAAC,GAAC,GACN,wBAAwB,CAqBpC;IAED;;OAEG;IACH,OAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAJW,MAAM,OACN,GAAC,GACC,wBAAwB,CAUpC;IAED;;;;OAIG;IACH,eAJW,MAAM,iBAEJ,wBAAwB,CAuBpC;IAED;;;;;;OAMG;IACH,YANW,MAAM,GAAC,OAAO,kCAEd,GAAG,EAAE,aACL,MAAM,GACJ,wBAAwB,CAkDpC;IAED;;;;OAIG;IACH,YAJW,GAAG,EAAE,GAAC,OAAO,kBAEX,wBAAwB,CA2CpC;IAED;;;;OAIG;IACH,YAJW,MAAM,GAAC,OAAO,GAAC,MAAM,kBAEnB,wBAAwB,CA4BpC;IAED;;;OAGG;IACH,YAHW,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,wBAAwB,CAWpC;IAED;;;OAGG;IACH,cAHW,OAAO,GAAC,OAAO,GAAC,MAAM,GACpB,wBAAwB,CAWpC;IAED;;OAEG;IACH,QAFa,wBAAwB,CAMpC;IAED;;OAEG;IACH,aAFa,wBAAwB,CAWpC;IAED;;;OAGG;IACH,qBAHW,MAAM,GAAC,OAAO,GACZ,wBAAwB,CAgBpC;IAED;;;OAGG;IACH,eAHW,WAAS,OAAO,GACd,wBAAwB,CAgBpC;IAED;;;;;;OAMG;IACH,gBANW,MAAM,GAAC,MAAM,SACb,MAAM,eACN,GAAG,EAAE,kBAEH,wBAAwB,CA2EpC;IAtBC,mBAAyB;IAwB3B;;;;;;OAMG;IACH,gBANW,MAAM,OACN,MAAM,GAAC,MAAM,mBACb,OAAO,GAEL,wBAAwB,CAqDpC;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,wBAAwB,CAWpC;IAED;;;;;;MAME;IACF,eAHU,MAAM,GACJ,wBAAwB,CAMnC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,wBAAwB,CAQpC;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAWlB;CACF;uCAtkBsC,iCAAiC"}

package/dist/XPathTransformer.d.ts

@@ -0,0 +1,51 @@
+export default XPathTransformer;
+/**
+ * Applies named XPath-driven templates to XML/HTML DOM data.
+ *
+ * Finds templates whose `path` XPath matches the current node (plus optional
+ * `mode`), sorts by priority, and invokes the winning template.
+ * Falls back to default rules when no template matches.
+ */
+declare class XPathTransformer {
+    static DefaultTemplateRules: {
+        transformRoot: {
+            /**
+             * @param {*} node Node
+             * @param {{mode:string}} cfg Config
+             * @returns {void}
+             */
+            template(node: any, cfg: {
+                mode: string;
+            }): void;
+        };
+    };
+    /**
+     * @param {object} config Configuration
+     * @param {boolean} [config.errorOnEqualPriority] Throw on equal priority
+     * @param {any[]} config.templates Template objects
+     * @param {number} [config.xpathVersion] XPath version (1|2)
+     */
+    constructor(config: {
+        errorOnEqualPriority?: boolean | undefined;
+        templates: any[];
+        xpathVersion?: number | undefined;
+    });
+    _config: {
+        errorOnEqualPriority?: boolean | undefined;
+        templates: any[];
+        xpathVersion?: number | undefined;
+    };
+    /** @type {any[]} */
+    rootTemplates: any[];
+    templates: any[];
+    /**
+     * @returns {void}
+     */
+    _triggerEqualPriorityError(): void;
+    /**
+     * @param {string} mode Transformation mode
+     * @returns {*} Result of transformation
+     */
+    transform(mode: string): any;
+}
+//# sourceMappingURL=XPathTransformer.d.ts.map

package/dist/XPathTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XPathTransformer.d.ts","sourceRoot":"","sources":["../src/XPathTransformer.js"],"names":[],"mappings":";AAEA;;;;;;GAMG;AACH;IAsEE;;YAEI;;;;eAIG;2BAHQ,GAAC,OACD;gBAAC,IAAI,EAAC,MAAM,CAAA;aAAC,GACX,IAAI;;MAMnB;IAhFF;;;;;OAKG;IACH,oBAJG;QAAyB,oBAAoB;QACvB,SAAS,EAAvB,GAAG,EAAE;QACW,YAAY;KACtC,EA4BA;IAzBC;;mBALS,GAAG,EAAE;;MAKO;IACrB,oBAAoB;IACpB,eADW,GAAG,EAAE,CACO;IACvB,iBAAiC;IAwBnC;;OAEG;IACH,8BAFa,IAAI,CAShB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,GAAC,CAkBb;CAcF"}

package/dist/XPathTransformerContext.d.ts

@@ -0,0 +1,260 @@
+export default XPathTransformerContext;
+/**
+ * Execution context for XPath-driven template application.
+ *
+ * Similar to JSONPathTransformerContext but uses XPath expressions on a
+ * DOM/XML-like tree. Supports XPath 1.0 (default) or 2.0 when
+ * `xpathVersion: 2`.
+ *
+ * Expected config:
+ * - data: A Document, Element, or XML-like root node.
+ * - joiningTransformer: joiner with append(), string(), object(), array(), etc.
+ * - xpathVersion: 1|2 (default 1)
+ * - errorOnEqualPriority, specificityPriorityResolver (same semantics).
+ */
+declare class XPathTransformerContext {
+    /**
+     * Log a message (for debugging).
+     * @param {*} json Any value
+     * @returns {void}
+     */
+    static message(json: any): void;
+    static DefaultTemplateRules: {
+        transformRoot: {
+            /**
+             * @param {*} node Root node
+             * @param {{mode:string}} cfg Config
+             * @returns {void}
+             */
+            template(node: any, cfg: {
+                mode: string;
+            }): void;
+        };
+        transformElements: {
+            /**
+             * @param {*} node Element node
+             * @param {{mode:string}} cfg Config
+             * @returns {void}
+             */
+            template(node: any, cfg: {
+                mode: string;
+            }): void;
+        };
+        transformTextNodes: {
+            /**
+             * @param {{nodeValue:string}} node Text node
+             * @returns {string}
+             */
+            template(node: {
+                nodeValue: string;
+            }): string;
+        };
+        transformScalars: {
+            /** @returns {*} */
+            template(): any;
+        };
+    };
+    /**
+     * @param {object} config - Configuration object
+     * @param {Document|Element|any} config.data - XML/DOM root to transform
+     * @param {number} [config.xpathVersion] - 1 or 2 (default 1)
+    * @param {object} config.joiningTransformer Joiner
+    * @param {Function} config.joiningTransformer.append Append output
+    * @param {Function} config.joiningTransformer.get Get output
+    * @param {Function} config.joiningTransformer.string Emit string
+    * @param {Function} config.joiningTransformer.object Emit object
+    * @param {Function} config.joiningTransformer.array Emit array
+     * @param {boolean} [config.errorOnEqualPriority]
+     * @param {Function} [config.specificityPriorityResolver]
+     * @param {any[]} templates - Template objects
+     */
+    constructor(config: {
+        data: Document | Element | any;
+        xpathVersion?: number | undefined;
+        joiningTransformer: {
+            append: Function;
+            get: Function;
+            string: Function;
+            object: Function;
+            array: Function;
+        };
+        errorOnEqualPriority?: boolean | undefined;
+        specificityPriorityResolver?: Function | undefined;
+    }, templates: any[]);
+    _config: {
+        data: Document | Element | any;
+        xpathVersion?: number | undefined;
+        joiningTransformer: {
+            append: Function;
+            get: Function;
+            string: Function;
+            object: Function;
+            array: Function;
+        };
+        errorOnEqualPriority?: boolean | undefined;
+        specificityPriorityResolver?: Function | undefined;
+    };
+    _templates: any[];
+    _contextNode: any;
+    _origNode: any;
+    /** @type {Record<string, any>} */
+    vars: Record<string, any>;
+    /** @type {Record<string, any>} */
+    propertySets: Record<string, any>;
+    /** @type {Record<string, any>} */
+    keys: Record<string, any>;
+    /** @type {boolean|undefined} */
+    _initialized: boolean | undefined;
+    /** @type {string|undefined} */
+    _currPath: string | undefined;
+    /** @returns {any} */
+    _getJoiningTransformer(): any;
+    /**
+     * Evaluate an XPath expression against the current context node.
+     * @param {string} expr - XPath expression
+    * @param {boolean} [asNodes] Return nodes (array) instead of scalar
+     * @returns {any}
+     */
+    _evalXPath(expr: string, asNodes?: boolean): any;
+    /**
+     * Append raw item to output.
+     * @param {*} item
+     * @returns {XPathTransformerContext}
+     */
+    appendOutput(item: any): XPathTransformerContext;
+    /** @returns {*} */
+    getOutput(): any;
+    /**
+     * Get value(s) by XPath relative to current context.
+     * @param {string} select - XPath expression
+     * @param {boolean} [asNodes]
+     * @returns {*}
+     */
+    get(select: string, asNodes?: boolean): any;
+    /**
+     * Set current context's parent property (for parity with JSONPath context).
+     * Mostly placeholder for object-mirroring behavior.
+     * @param {*} v
+     * @returns {XPathTransformerContext}
+     */
+    set(v: any): XPathTransformerContext;
+    /**
+     * Apply templates to nodes matched by an XPath expression.
+     * @param {string} select - XPath expression (default '.')
+     * @param {string} [mode]
+     * @returns {XPathTransformerContext}
+     */
+    applyTemplates(select: string, mode?: string): XPathTransformerContext;
+    /**
+     * Iterate over nodes selected by XPath.
+     * @param {string} select - XPath expression
+     * @param {Function} cb - Callback invoked per node
+     * @returns {XPathTransformerContext}
+     */
+    forEach(select: string, cb: Function): XPathTransformerContext;
+    /**
+     * Append the value from an XPath expression or the context node text.
+     * @param {string|object} [select]
+     * @returns {XPathTransformerContext}
+     */
+    valueOf(select?: string | object): XPathTransformerContext;
+    /**
+     * Define a variable by XPath selection (stores node array if nodes).
+     * @param {string} name Variable name
+     * @param {string} select XPath expression
+     * @returns {XPathTransformerContext}
+     */
+    variable(name: string, select: string): XPathTransformerContext;
+    /**
+     * Append string.
+     * @param {string} str String to append
+     * @param {Function} [cb] Callback
+     * @returns {XPathTransformerContext}
+     */
+    string(str: string, cb?: Function): XPathTransformerContext;
+    /**
+     * Append number.
+     * @param {number} num Number
+     * @returns {XPathTransformerContext}
+     */
+    number(num: number): XPathTransformerContext;
+    /**
+     * Append plain text (no escaping changes).
+     * @param {string} str Text
+     * @returns {XPathTransformerContext}
+     */
+    plainText(str: string): XPathTransformerContext;
+    /**
+     * Append property/value pair.
+     * @param {string} prop Property name
+     * @param {*} val Value
+     * @returns {XPathTransformerContext}
+     */
+    propValue(prop: string, val: any): XPathTransformerContext;
+    /**
+     * Append object.
+     * @param {...any} args Object args
+     * @returns {XPathTransformerContext}
+     */
+    object(...args: any[]): XPathTransformerContext;
+    /**
+     * Append array.
+     * @param {...any} args Array args
+     * @returns {XPathTransformerContext}
+     */
+    array(...args: any[]): XPathTransformerContext;
+    /**
+     * Append element.
+     * @param {string} name Tag name
+     * @param {object} [atts] Attributes
+     * @param {any[]} [children] Children
+     * @param {Function} [cb] Callback
+     * @returns {XPathTransformerContext}
+     */
+    element(name: string, atts?: object, children?: any[], cb?: Function): XPathTransformerContext;
+    /**
+     * Append attribute.
+     * @param {string} name Attribute name
+     * @param {string|object} val Value
+     * @param {boolean} [avoid] Avoid duplicates
+     * @returns {XPathTransformerContext}
+     */
+    attribute(name: string, val: string | object, avoid?: boolean): XPathTransformerContext;
+    /**
+     * Append text node content.
+     * @param {string} txt Text
+     * @returns {XPathTransformerContext}
+     */
+    text(txt: string): XPathTransformerContext;
+    /**
+     * Define a property set (optionally composed from other sets).
+     * @param {string} name Property set name
+     * @param {object} obj Base properties
+     * @param {string[]} [use] Property set names to merge
+     * @returns {XPathTransformerContext}
+     */
+    propertySet(name: string, obj: object, use?: string[]): XPathTransformerContext;
+    /**
+     * Merge properties from a named property set into obj.
+     * @param {object} obj Target object
+     * @param {string} name Property set name
+     * @returns {object}
+     */
+    _usePropertySets(obj: object, name: string): object;
+    /**
+     * Retrieve a key-mapped node matching a value or return context.
+     * @param {string} name Key name
+     * @param {*} value Value to match
+     * @returns {*}
+     */
+    getKey(name: string, value: any): any;
+    /**
+     * Register a key for later lookup.
+     * @param {string} name Key name
+     * @param {string} match XPath selecting nodes
+     * @param {string} use Attribute (or property) name to compare
+     * @returns {XPathTransformerContext}
+     */
+    key(name: string, match: string, use: string): XPathTransformerContext;
+}
+//# sourceMappingURL=XPathTransformerContext.d.ts.map

package/dist/XPathTransformerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XPathTransformerContext.d.ts","sourceRoot":"","sources":["../src/XPathTransformerContext.js"],"names":[],"mappings":"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"}

package/dist/XSLTStyleJSONPathResolver.d.ts

@@ -0,0 +1,16 @@
+export default XSLTStyleJSONPathResolver;
+/**
+ * Computes a simple specificity score for JSONPath selectors inspired by XSLT.
+ *
+ * Used by the engine to break ties between templates when multiple JSONPath
+ * expressions match the same node. Lower values indicate broader matches
+ * (e.g., wildcards), while higher values indicate more specific matches.
+ */
+declare class XSLTStyleJSONPathResolver {
+    /**
+     * @param {string|string[]} path
+     * @returns {-0.5|0.5|0}
+     */
+    getPriorityBySpecificity(path: string | string[]): -0.5 | 0.5 | 0;
+}
+//# sourceMappingURL=XSLTStyleJSONPathResolver.d.ts.map

package/dist/XSLTStyleJSONPathResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XSLTStyleJSONPathResolver.d.ts","sourceRoot":"","sources":["../src/XSLTStyleJSONPathResolver.js"],"names":[],"mappings":";AAEA;;;;;;GAMG;AACH;IACE;;;OAGG;IAEH,+BAJW,MAAM,GAAC,MAAM,EAAE,GACb,CAAC,GAAG,GAAC,GAAG,GAAC,CAAC,CAuBtB;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,168 @@
+export { default as AbstractJoiningTransformer } from "./AbstractJoiningTransformer.js";
+export { default as StringJoiningTransformer } from "./StringJoiningTransformer.js";
+export { default as DOMJoiningTransformer } from "./DOMJoiningTransformer.js";
+export { default as JSONJoiningTransformer } from "./JSONJoiningTransformer.js";
+export { default as XSLTStyleJSONPathResolver } from "./XSLTStyleJSONPathResolver.js";
+export { default as JSONPathTransformerContext } from "./JSONPathTransformerContext.js";
+export { default as JSONPathTransformer } from "./JSONPathTransformer.js";
+export { default as XPathTransformerContext } from "./XPathTransformerContext.js";
+export { default as XPathTransformer } from "./XPathTransformer.js";
+export default JTLT;
+export type JTLTOptions = {
+    /**
+     * A callback supplied with a single
+     * argument that is the result of this instance's transform() method.
+     */
+    success: Function;
+    /**
+     * An array of template objects
+     */
+    templates?: any[] | undefined;
+    /**
+     * A function assumed to be a
+     * root template or a single, complete template object
+     */
+    template?: object | Function | undefined;
+    /**
+     * A function assumed to be a root template
+     */
+    query?: Function | undefined;
+    /**
+     * An array with arguments to be supplied
+     * to a single call to `forEach` (and which will serve as the root
+     * template)
+     */
+    forQuery?: any[] | undefined;
+    /**
+     * A JSON object
+     */
+    data?: any;
+    /**
+     * URL of a JSON file to retrieve for
+     * evaluation
+     */
+    ajaxData?: string | undefined;
+    /**
+     * Whether or not to
+     * report an error when equal priority templates are found
+     */
+    errorOnEqualPriority?: boolean | undefined;
+    /**
+     * Whether to begin transform()
+     * immediately.
+     */
+    autostart?: boolean | undefined;
+    /**
+     * Whether to prevent
+     * parenthetical evaluations in JSONPath. Safer if relying on user
+     * input, but reduces capabilities of JSONPath.
+     */
+    preventEval?: boolean | undefined;
+    /**
+     * For JSON output, whether to
+     * unwrap single-element root arrays to return just the element
+     */
+    unwrapSingleResult?: boolean | undefined;
+    /**
+     * The mode in which to begin the transform.
+     */
+    mode?: string | undefined;
+    /**
+     * Output type: 'string', 'dom', or 'json'
+     */
+    outputType?: string | undefined;
+    /**
+     * Will be based the
+     * same config as passed to this instance. Defaults to a transforming
+     * function based on JSONPath and with its own set of priorities for
+     * processing templates.
+     */
+    engine?: Function | undefined;
+    /**
+     * Choose built-in engine.
+     * Defaults to 'jsonpath'. When 'xpath', `xpathVersion` may be used.
+     */
+    engineType?: "jsonpath" | "xpath" | undefined;
+    /**
+     * XPath engine version: 1 (native) or 2
+     * (xpath2.js) when `engineType` is 'xpath'.
+     */
+    xpathVersion?: 1 | 2 | undefined;
+    /**
+     * Callback for getting the priority by specificity
+     */
+    specificityPriorityResolver?: Function | undefined;
+    /**
+     * Can
+     * be a singleton or class instance. Defaults to string joining for output
+     * transformation.
+     */
+    joiningTransformer?: {
+        get: Function;
+        append: Function;
+        string?: Function;
+        object?: Function;
+        array?: Function;
+    } | undefined;
+    /**
+     * Config to pass on to the joining
+     * transformer
+     */
+    joiningConfig?: object | undefined;
+    /**
+     * Parent object for context
+     */
+    parent?: any;
+    /**
+     * Parent property name for context
+     */
+    parentProperty?: string | undefined;
+};
+/**
+ * High-level façade for running a JTLT transform.
+ *
+ * Accepts data and templates (or a root template/query), constructs a joining
+ * transformer based on `outputType`, and invokes the JSONPath-based engine.
+ * The result is returned to the required `success` callback and also returned
+ * from transform().
+ */
+declare class JTLT {
+    /**
+     * For templates/queries, one may choose among config.query,
+     * config.template, or config.templates, but one must be
+     * present and of valid type. For the source json, one must use
+     * either a valid config.ajaxData or config.data parameter.
+     * @param {JTLTOptions} config Options
+     * @todo Remove JSONPath dependency in query use of '$'?
+     */
+    constructor(config: JTLTOptions);
+    /** @type {JTLTOptions} */
+    config: JTLTOptions;
+    /**
+     * @returns {DOMJoiningTransformer|JSONJoiningTransformer|
+     *   StringJoiningTransformer}
+     */
+    _createJoiningTransformer(): DOMJoiningTransformer | JSONJoiningTransformer | StringJoiningTransformer;
+    /**
+     * @param {string} mode
+     * @returns {void}
+     */
+    _autoStart(mode: string): void;
+    /**
+     * @param {JTLTOptions} config
+     * @returns {JTLT}
+     */
+    setDefaults(config: JTLTOptions): JTLT;
+    /**
+     * @param {string} mode The mode of the transformation
+     * @returns {any} Result of transformation
+     * @todo Allow for a success callback in case the jsonpath code is modified
+     *     to work asynchronously (as with queries to access remote JSON
+     *     stores)
+     */
+    transform(mode: string): any;
+}
+import DOMJoiningTransformer from './DOMJoiningTransformer.js';
+import JSONJoiningTransformer from './JSONJoiningTransformer.js';
+import StringJoiningTransformer from './StringJoiningTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0Bc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8BH,GAAG;;;;;;AAOjB;;;;;;;GAOG;AACH;IACE;;;;;;;OAOG;IACH,oBAHW,WAAW,EA4BrB;IAxBC,0BAA0B;IAC1B,QADW,WAAW,CACI;IAyB5B;;;OAGG;IACH,6BAHa,qBAAqB,GAAC,sBAAsB,GACpD,wBAAwB,CAuD5B;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,IAAI,CAYhB;IAED;;;OAGG;IACH,oBAHW,WAAW,GACT,IAAI,CAoDhB;IAED;;;;;;OAMG;IACH,gBANW,MAAM,GACJ,GAAG,CA2Bf;CACF;kCApQiC,4BAA4B;mCAC3B,6BAA6B;qCAG3B,+BAA+B"}