jtlt 0.1.0

package/.editorconfig

@@ -0,0 +1,16 @@
+; EditorConfig file: https://EditorConfig.org
+; Install the "EditorConfig" plugin into your editor to use
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+; [app/public/css/**.styl]
+; indent_style = tab
+; indent_size = 2

package/CHANGES.md

@@ -0,0 +1,5 @@
+# jtlt CHANGES
+
+## 0.1.0
+
+- Initial version

package/LICENSE-MIT.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Brett Zamir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,534 @@
+# jtlt
+
+JavaScript Template Language Transformations (JTLT, pronounced as
+"Jetlet")—a JavaScript equivalent of [XSLT](https://www.w3.org/Style/XSL/),
+for JSON/JavaScript object data sources.
+
+As with XSLT, allows for declarative, linear declaration of
+(recursive) templates and can be transformed into different
+formats (e.g., HTML strings, JSON, DOM objects, etc.).
+
+***Beta state!!!***
+
+## Credits
+
+Packaged with [JSONPath Plus](https://github.com/s3u/JSONPath).
+
+The sample file is from <https://goessner.net/articles/JsonPath/>
+
+## Installation
+
+```shell
+npm install .
+```
+
+In the browser, you will also need to include the dependencies.
+See the [test file](test/test.html).
+
+## Basic usage
+
+### Node
+
+### Browser
+
+## API
+
+See the [docs](docs/API.md). A high‑level overview is below.
+
+## API overview
+
+JTLT has two layers:
+
+- Engine (template application):
+    - JSONPathTransformer: Applies templates to JSON by matching JSONPath selectors (and optional modes), resolving priority, and invoking the winning template. Falls back to built‑in default rules when no user template matches.
+    - JSONPathTransformerContext: The execution context passed to templates. It mirrors the joiner API (e.g., string(), object(), array()) so templates can emit results. It also provides helpers like applyTemplates(), callTemplate(), valueOf(), variable(), and forEach().
+    - XPathTransformer (experimental): Applies templates to
+      XML/HTML DOM by matching XPath selectors (and optional modes).
+      Supports two evaluation modes: version 1 (native
+      XPathEvaluator) and version 2 (via xpath2.js). Falls back to
+      built‑in default rules when no template matches.
+    - XPathTransformerContext (experimental): Execution context for
+      XPath. Offers get(), forEach(), valueOf(), variable(), key()
+      and the same joiner helpers as the JSONPath context.
+
+- Joiners (output builders):
+    - StringJoiningTransformer: Builds a string. Context‑aware append() routes into objects/arrays when inside object()/array() scopes, otherwise concatenates to a buffer. Includes element(), attribute(), and text() helpers for HTML/XML emission.
+    - DOMJoiningTransformer: Builds a DocumentFragment/Element tree. element()/attribute()/text() add real nodes; primitives append as text nodes.
+    - JSONJoiningTransformer: Builds real JS values (objects/arrays/primitives) without serialization.
+
+### Common joiner methods
+
+- append(value): Central sink. Based on context, concatenates to string, pushes to array, or assigns to an object property.
+- get(): Return the accumulated result.
+- object(obj?, cb?, usePropertySets?, propSets?): Enter object context; optionally seed from an object or build via cb.
+- array(arr?, cb?): Enter array context; optionally seed from an array or build via cb.
+- string(str, cb?): Emit a string value (no HTML escaping). In String joiner, optional cb lets you compose nested fragments before emitting.
+- number(num), boolean(bool), null(), undefined() (JS mode only), nonfiniteNumber(NaN|Infinity), function(fn) (JS mode only): Emit primitives/functions.
+- element(name, attrs?, children?, cb?): Build elements (String and DOM joiners). In String joiner, uses Jamilih under the hood to serialize; in DOM joiner, creates Elements.
+- attribute(name, value, avoidEscape?): Add attributes to the most recently opened element (String joiner) or to the current Element (DOM joiner).
+- text(txt): Emit text content. In String joiner, escapes & and <, and closes an open start tag if needed.
+- plainText(str): Raw, no‑escape append that bypasses context routing in the String joiner (always writes to top‑level buffer). In DOM/JSON joiners, it maps to text()/string() respectively.
+
+### string() vs text() vs plainText() (String joiner)
+
+- text(): Escapes &, < and closes an open start tag. Use for safe text nodes in markup.
+- string(): No HTML escaping or JSON stringify; routes via append() so it participates in object()/array()/propOnly() states. Optional cb to build a composite string before emitting.
+- plainText(): Always writes directly to the top‑level string buffer with no escaping, ignoring object/array state. Useful for deliberate raw insertion.
+
+### Configuration quick reference
+
+Provide joiningConfig when constructing JTLT:
+
+- joiningConfig.mode: 'JavaScript' or 'JSON' controls allowance of undefined/functions/non‑finite numbers in the String joiner.
+- joiningConfig.JHTMLForJSON: If true, object()/array() serialize via JHTML instead of JSON.
+- joiningConfig.xmlElements: Switch element() to XML serialization mode in the String joiner.
+- joiningConfig.preEscapedAttributes: Skip escaping attribute values in the String joiner.
+
+### XPath (experimental)
+
+You can run templates against XML/HTML using XPath instead of JSONPath.
+
+- Construct with `new XPathTransformer({data, templates,
+  joiningTransformer, xpathVersion})`.
+- `data` should be a Document or Element (e.g., from DOMParser with
+  `text/xml`).
+- `xpathVersion`: `1` uses native XPath (browser like). `2` uses
+  `xpath2.js` for XPath 2.0‑style evaluation.
+- In version 2, some functions may be missing; prefer simple path
+  expressions. Use version 1 for wide XPath 1.0 function support.
+
+Example (string output):
+
+```js
+import {JSDOM} from 'jsdom';
+import {StringJoiningTransformer, XPathTransformer} from 'jtlt';
+
+const {window} = new JSDOM('<!doctype><html><body></body></html>');
+const parser = new window.DOMParser();
+const doc = parser.parseFromString(
+  '<root><item>a</item><item>b</item></root>', 'text/xml'
+);
+
+const joiner = new StringJoiningTransformer('', {document: doc});
+const templates = [
+  {name: 'root', path: '/', template () {
+    this.applyTemplates('//item');
+  }},
+  {name: 'item', path: '//item', template (node) {
+    this.element('li', {}, [], () => this.text(node.textContent));
+  }}
+];
+
+const out = new XPathTransformer({
+  data: doc,
+  templates,
+  joiningTransformer: joiner,
+  xpathVersion: 1 // or 2
+}).transform('');
+// -> <li>a</li><li>b</li>
+```
+
+Using the JTLT facade with XPath (no manual joiner needed):
+
+```js
+import {JSDOM} from 'jsdom';
+import JTLT from 'jtlt';
+
+const {window} = new JSDOM('<!doctype><html><body></body></html>');
+const parser = new window.DOMParser();
+const doc = parser.parseFromString(
+  '<root><item>a</item><item>b</item></root>', 'text/xml'
+);
+
+const templates = [
+  {
+    path: '/',
+    template () {
+      this.applyTemplates('//item');
+    }
+  },
+  {
+    path: '//item',
+    template (n) {
+      this.string('<li>', () => this.text(n.textContent));
+      this.string('</li>');
+    }
+  }
+];
+
+const out = new JTLT({
+  data: doc,
+  templates,
+  outputType: 'string',
+  engineType: 'xpath',
+  xpathVersion: 1, // or 2
+  success: (res) => res
+}).transform('');
+// -> <li>a</li><li>b</li>
+```
+
+## Quick start
+
+```js
+import JTLT from 'jtlt';
+
+const data = {title: 'Hello', items: ['a', 'b']};
+
+const templates = [
+  {path: '$', template () {
+    this.applyTemplates({mode: 'html'});
+  }},
+  {mode: 'html', path: '$.title', template (v) {
+    this.string('<h1>', () => this.text(v));
+    this.string('</h1>');
+  }},
+  {mode: 'html', path: '$.items[*]', template (v) {
+    this.element('li', {}, [], () => this.text(v));
+  }}
+];
+
+const out = new JTLT({data, templates, outputType: 'string'}).
+  transform('html');
+
+console.log(out);
+```
+
+Notes:
+
+- Modes let you organize multiple passes or output targets.
+- You can also call templates by name via this.callTemplate('name').
+- For DOM output, use outputType: 'dom'. For JSON output, use 'json'.
+
+## One-off queries with forQuery (XQuery-like)
+
+If you just want to run a single, non-recursive query (similar to an XQuery "for … where … return …"), you can skip defining templates and use `forQuery` to seed a root function that iterates a JSONPath and emits results.
+
+- `forQuery` takes the same arguments you’d pass to `this.forEach(select, cb)`: an absolute JSONPath selector and a callback invoked for each match.
+- You can set variables via `this.variable(name, select)` and use plain JavaScript `if` for conditions (there is no dedicated `this.if`).
+
+Example: collect item names whose price meets a threshold, using a variable sourced from the root.
+
+```js
+import JTLT from 'jtlt';
+
+const data = {
+  threshold: 10,
+  items: [
+    {name: 'A', price: 8},
+    {name: 'B', price: 12},
+    {name: 'C', price: 10}
+  ]
+};
+
+const jtlt = new JTLT({
+  data,
+  outputType: 'json', // Top-level result will be a JSON array
+  // forQuery mirrors: this.forEach(select, cb)
+  forQuery: [
+    '$.items[*]',
+    function (item) {
+      // Set a reusable variable from the root context
+      this.variable('threshold', '$.threshold');
+      const {threshold} = this.vars;
+
+      // Use normal JS conditionals (no this.if helper)
+      if (item.price >= threshold) {
+        // In JSON output mode, appending a string pushes into
+        //   the top-level array
+        this.string(item.name);
+      }
+    }
+  ],
+  // success receives the final result; return it for convenience
+  success: (out) => out
+});
+
+const result = jtlt.transform();
+// result => ['B', 'C']
+```
+
+Tips:
+
+- For string output, set `outputType: 'string'` and emit with `this.text()`/`this.string()` in the callback.
+- `this.variable(name, select)` evaluates the JSONPath against the current context (root for `forQuery`), storing it in `this.vars[name]`.
+- If you need multiple passes or richer logic, switch to named templates and modes.
+
+## FLWOR-style (XQuery) example
+
+You can express the essentials of a FLWOR expression (For, Let, Where, Order by, Return) using a template with `forEach()` and the new `sort` support:
+
+Scenario: list book titles whose price is at/above a threshold, ordered by price descending and then title ascending.
+
+```js
+import JTLT from 'jtlt';
+
+const data = {
+  threshold: 10,
+  store: {
+    book: [
+      {title: 'A Tale', price: 8},
+      {title: 'Brave New', price: 12},
+      {title: 'Cobalt', price: 12},
+      {title: 'Delta', price: 10}
+    ]
+  }
+};
+
+const templates = [
+  // Root template builds an HTML list
+  {path: '$', mode: 'html', template () {
+    // Let: bind a reusable variable from root
+    this.variable('threshold', '$.threshold');
+
+    this.element('ul', {}, [], () => {
+      // For + Order by: iterate books with multi-key sort
+      this.forEach('$.store.book[*]', function (b) {
+        // Where: filter in JS
+        if (b.price >= this.vars.threshold) {
+          // Return: emit a list item for each match
+          this.element('li', {}, [], () => this.text(b.title));
+        }
+      }, [
+        {select: '$.price', type: 'number', order: 'descending'},
+        {select: '$.title', type: 'text', order: 'ascending'}
+      ]);
+    });
+  }}
+];
+
+const out = new JTLT({data, templates, outputType: 'string'}).
+  transform('html');
+
+// -> <ul><li>Brave New</li><li>Cobalt</li><li>Delta</li></ul>
+console.log(out);
+```
+
+Notes:
+
+- You can also drive a FLWOR-like flow with `applyTemplates({select, mode}, sort)` and a dedicated template `mode` instead of using an inline `forEach()` callback.
+- The `sort` parameter accepts:
+  - a JSONPath string relative to each item (e.g., `$.name` or `.`)
+  - a comparator function `(aValue, bValue, ctx) => number`
+  - an object `{select, order, type, locale, localeOptions}`
+  - an array of such strings/objects for multi-key sorting
+
+## FLWOR-style join (two forEach loops)
+
+You can model a join across two arrays (e.g., orders ↔ customers) using two `forEach()` passes: the first builds a lookup (an index), the second consumes it to emit joined rows. This mirrors a FLWOR-style join while keeping intent explicit and fast.
+
+Example: render an HTML list of orders annotated with customer names.
+
+```js
+import JTLT from 'jtlt';
+
+const data = {
+  customers: [
+    {id: 1, name: 'Alice'},
+    {id: 2, name: 'Bob'}
+  ],
+  orders: [
+    {id: 'o-10', customerId: 2, item: 'Keyboard', date: '2024-10-01'},
+    {id: 'o-11', customerId: 1, item: 'Mouse', date: '2024-09-20'}
+  ]
+};
+
+const templates = [
+  {path: '$', mode: 'html', template () {
+    // 1) Build an index by id (first forEach)
+    const byId = {};
+    this.forEach('$.customers[*]', function (c) {
+      byId[c.id] = c;
+    });
+
+    // 2) Emit joined rows (second forEach)
+    this.element('ul', {}, [], () => {
+      this.forEach('$.orders[*]', function (o) {
+        const c = byId[o.customerId];
+        if (!c) {
+          return; // skip if no matching customer
+        }
+        this.element('li', {}, [], () => {
+          this.text(`${c.name} — ${o.item}`);
+        });
+      }, {select: '$.date', type: 'text', order: 'ascending'}); // optional sort
+    });
+  }}
+];
+
+const out = new JTLT({data, templates, outputType: 'string'}).transform('html');
+// -> <ul><li>Bob — Keyboard</li><li>Alice — Mouse</li></ul>
+console.log(out);
+```
+
+Notes:
+
+- This pattern uses two `forEach()` calls rather than nesting them, which avoids repeatedly scanning the second array for each outer item.
+- If you already maintain keys in your data, you can skip the first pass and derive `byId` with `Object.fromEntries` or similar.
+- For locale-aware or numeric ordering of the second pass, use the `sort` parameter (string/comparator/object/array as shown above).
+
+
+## Joins with key()/getKey() (xsl:key-like)
+
+Define an index once, then perform O(1) lookups from another sequence when rendering. If no match is found, `getKey()` returns the current context (`this`) as a sentinel; check for that to skip safely.
+
+```js
+import JTLT from 'jtlt';
+
+const data = {
+  customers: [
+    {id: 1, name: 'Alice'},
+    {id: 2, name: 'Bob'}
+  ],
+  orders: [
+    {id: 'o-10', customerId: 2, item: 'Keyboard'},
+    {id: 'o-11', customerId: 3, item: 'Cable'} // no matching customer
+  ]
+};
+
+const templates = [
+  {path: '$', mode: 'html', template () {
+    // Define an index by id: key(name, match, use)
+    this.key('customerById', '$.customers[*]', 'id');
+
+    this.element('ul', {}, [], () => {
+      this.forEach('$.orders[*]', function (o) {
+        const c = this.getKey('customerById', o.customerId);
+        // getKey returns `this` if no match; skip such rows
+        if (c === this) {
+          return;
+        }
+        this.element('li', {}, [], () => this.text(`${c.name}: ${o.item}`));
+      }, {select: '$.id', order: 'ascending'});
+    });
+  }}
+];
+
+const out = new JTLT({data, templates, outputType: 'string'}).transform('html');
+// -> <ul><li>Bob: Keyboard</li></ul>
+console.log(out);
+```
+
+Tips:
+
+- You can define multiple keys with different `use` properties (e.g., lookup by `email`, `id`, etc.).
+- The `match` expression can target nested arrays (e.g., `$.stores[*].customers[*]`).
+- For JSON output joins, switch `outputType: 'json'` and use `object()`/`array()` to build structured results.
+
+## How this compares to XSLT: pros and cons
+
+Advantages (strong parallels with XSLT):
+
+- Template matching by path and mode: templates use JSONPath selectors and optional `mode`, with priority resolution and an option to error on equal priority.
+- Built‑in default rules: when no template matches, defaults traverse and render objects, arrays, scalars, property names, and functions, similar to XSLT’s built‑in templates.
+- applyTemplates/forEach and sorting: `applyTemplates(select, mode, sort)` and `forEach(select, cb, sort)` mirror `xsl:apply-templates`/`xsl:for-each` and `xsl:sort`.
+- Named templates and parameters: `callTemplate(name, withParam)` reflects `xsl:call-template` + `xsl:with-param`.
+- Keys and lookups: `key(name, match, use)` + `getKey(name, value)` provide `xsl:key`-style indexing for joins and fast lookups.
+- Multiple output forms: string, DOM, and JSON builders ("joiners") allow emitting different result trees like XSLT’s result tree model.
+
+Differences / current limitations:
+
+- Expression language: XPath 2.0 implementation is not fully feature complete.
+- Stylesheet composition/precedence: no `xsl:import`/`xsl:include` equivalents; only basic priority and modes.
+- Schema awareness: no type-aware processing (a major XSLT/XQuery feature).
+- Multi-output (`xsl:result-document`): not built-in; pick one output type per transform.
+
+## Differences between an exact equivalence with XSLT
+
+JTLT, having the freedom to start a new pattern from XSLT, and though
+seeking to learn from it, deviates somewhat from making an exact
+equivalence with XSLT (to the extent JTLT and JSONPath implement
+what could possibly be transferred to JSON-based transformations
+from XSLT):
+
+1.  Although the option is given for throwing errors upon finding
+    templates of equal priority, the default behavior is to give
+    preference to the last template (unlike XSLT which makes it an
+    error by default).
+
+## To-dos
+
+1.  Document and add test cases to cover current features! (Could adapt an XSLT/XQuery test suite)
+
+    1.  Implement and demo equivalent to applying and calling templates, and
+        root template
+
+    2.  Demo chaining of methods, including [equivalents](https://www.saxonica.com/papers/XTech2005/mhkpaper.html#S4.)
+        to XQuery's FLWOR expressions (see also Promises to-do), perhaps
+        even making aliases so that XQuery's friendlier terms can be used
+        instead of XSLT's.
+
+2.  Support processing of JSON documents with `$jtlt-stylesheet` to let
+    documents define their own targeted stylesheets.
+
+3.  When sufficiently documented, add as example library/tool to
+    JSONPath wiki.
+
+4.  Allow alternative to `element()`, `array()`, etc. methods by just
+    detecting those types from return values (and generic of each
+    type like `dom()` and `json()`).
+
+5.  Allow, depending on mode, containers to contain containers of other
+    types (e.g., a JS container containing DOM objects, or temporary use
+    of a string container, etc.).
+
+    1.  Support XML and add [hXML](https://github.com/brettz9/hxml) methods.
+
+    2.  Support [JHTML](https://github.com/brettz9/jhtml).
+
+    3.  Support `appendJSON()`/`appendDOM()` and
+        `appendType('json', ...)` (allowing type extensions).
+
+6.  Add `appendResult(function () {return result})`.
+
+7.  Add JSON update functions (equivalent to Xquery Update Facility for
+    XML ([overview](http://www.xmlplease.com/xquery-update))) and create
+    JSON serialization (as with XSLT expressed itself in declarative XML)
+    so one can submit and evaluate
+    through [HTTPQuery](https://github.com/brettz9/httpquery) (and also
+    supply to JSONEditor, etc.). Utilize updating by reference.
+
+8. Demo narrowing to subset of JavaScript (as with `jspe`) to make
+    JTLT truly "declarative" as far as freedom from scripting
+
+## Possible to-dos
+
+1.  Make schema-aware so that templates could target types. Most reusable
+    application may be having a type-driven view of a JSON Schema instance
+    (e.g., dates could be shown inside a calendar widget). Perhaps this
+    schema-awareness could also drive a JSON editor (as with other existing
+    projects) (even using same API as JSONEditor?) (or type-aware filtered
+    search/raw queries). This would help not only for editors which edit a
+    JSON file in full, but also for providing schema paths or other identifiers
+    so that a transformed/queried subset of a file (or joining of multiple
+    files) could point the way for edited contents to be saved back to the
+    correct JSON file and position in the JSON file.
+
+2.  Add a [non-eval PR for JSONPath](https://github.com/s3u/JSONPath/pull/4).
+    The OR condition (outside of filters) is another important feature as
+    would be schema-aware path results.
+
+3.  Allow hybrid JSON/[Jamilih](https://github.com/brettz9/jamilih) or
+    JSON/(X)HTML/XML so that one can add
+    XPath or query into HTML in a relevant manner
+
+4.  Support pull parsing/streaming? Pass `done()` function to templates to
+    signal completion?
+
+5.  Support Promise API in addition to callbacks (reconcile with
+    current chaining; see also XQuery FLWOR to-do)
+
+6.  Add [XQuery Functions](https://code.google.com/p/jsxqueryparser/source/browse/trunk/jsxqueryparser/XQueryParser.js#1768)
+    (also supporting DOM and JSON where possible) as plug-in (also any
+    missing from XSLT/XQuery 3.0). Also add, if not present among these
+    functions (or in XQuery), add equivalents to XSLT's
+    `document()` and `unparsed-text()` for allowing non-JSON file
+    retrieval (as well as variables/parameters) and also methods for
+    iterating or retrieving IndexedDB, `localStorage`, and cookies
+    (names, keys and values).
+
+7.  Add `outputType` which uses a DOM joiner but allows specialized
+    serialized output (e.g., pretty-printed HTML) so the users
+    don't need to build it themselves (likewise with stringified
+    JSON output).
+
+8.  See code for other possible to-dos

package/dist/AbstractJoiningTransformer.d.ts

@@ -0,0 +1,42 @@
+export default AbstractJoiningTransformer;
+/**
+ * Base class for joining transformers.
+ *
+ * A "joining transformer" is the sink that receives template outputs and
+ * accumulates them into a particular representation (string, DOM, JSON).
+ * Subclasses implement a consistent set of methods (string, number, object,
+ * array, element, text, etc.) but may interpret them differently according
+ * to their target representation.
+ *
+ * Common patterns supported by all joiners:
+ * - append(): central method that either concatenates, pushes, or assigns
+ *   based on the current state.
+ * - get(): returns the accumulated result.
+ * - config(): temporarily tweak a config flag for the duration of a callback.
+ */
+declare class AbstractJoiningTransformer {
+    /**
+     * @param {object} [cfg] - Configuration object
+     */
+    constructor(cfg?: object);
+    /**
+     * @param {any} [cfg] - Configuration object
+     * @returns {void}
+     */
+    setConfig(cfg?: any): void;
+    _cfg: any;
+    /**
+     * @param {string} type - Type name
+     * @param {string} embedType - Embed type name
+     * @returns {void}
+     */
+    _requireSameChildren(type: string, embedType: string): void;
+    /**
+     * @param {string} prop - Configuration property name
+     * @param {*} val - Configuration property value
+     * @param {Function} [cb] - Callback function
+     * @returns {void}
+     */
+    config(prop: string, val: any, cb?: Function): void;
+}
+//# sourceMappingURL=AbstractJoiningTransformer.d.ts.map

package/dist/AbstractJoiningTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/AbstractJoiningTransformer.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;GAcG;AACH;IACE;;OAEG;IACH,kBAFW,MAAM,EAKhB;IAED;;;OAGG;IACH,gBAHW,GAAG,GACD,IAAI,CAIhB;IADC,UAAe;IAGjB;;;;OAIG;IACH,2BAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAUhB;IAED;;;;;OAKG;IACH,aALW,MAAM,OACN,GAAC,kBAEC,IAAI,CAchB;CACF"}