jtlt 0.2.0 → 0.4.0

package/demo/vendor/simple-get-json/dist/index-es.js

@@ -0,0 +1,151 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+/**
+ * @typedef {JSONValue[]} JSONArray
+ */
+/**
+ * @typedef {null|boolean|number|string|JSONArray|{[key: string]: JSONValue}} JSONValue
+ */
+
+/**
+* @callback SimpleJSONCallback
+* @param {...JSONValue} json
+* @returns {void}
+*/
+
+/**
+* @callback SimpleJSONErrback
+* @param {Error} err
+* @param {string|string[]} jsonURL
+* @returns {JSONValue}
+*/
+
+/**
+ * @typedef {((
+ *   jsonURL: string|string[],
+ *   cb?: SimpleJSONCallback,
+ *   errBack?: SimpleJSONErrback
+ * ) => Promise<JSONValue>) & {
+ *   _fetch?: import('./index-polyglot.js').SimpleFetch,
+ *   hasURLBasePath?: boolean,
+ *   basePath?: string|false
+ * }} getJSONCallback
+ */
+
+/**
+ * @param {object} [cfg]
+ * @param {import('./index-polyglot.js').SimpleFetch} [cfg.fetch]
+ * @returns {getJSONCallback}
+ */
+
+function _await(value, then, direct) {
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+}
+function _invoke(body, then) {
+  var result = body();
+  if (result && result.then) {
+    return result.then(then);
+  }
+  return then(result);
+}
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+function buildGetJSONWithFetch() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$fetch = _ref.fetch,
+    fetch = _ref$fetch === void 0 ? typeof window !== 'undefined' ? window.fetch : self.fetch : _ref$fetch;
+  /**
+  * @type {getJSONCallback}
+  */
+  return function getJSON(jsonURL, cb, errBack) {
+    try {
+      var _exit = false;
+      return _await(_catch(function () {
+        return _invoke(function () {
+          if (Array.isArray(jsonURL)) {
+            return _await(Promise.all(jsonURL.map(function (url) {
+              return /** @type {getJSONCallback} */getJSON(url);
+            })), function (arrResult) {
+              if (cb) {
+                // eslint-disable-next-line promise/prefer-await-to-callbacks -- Old-style API
+                cb.apply(void 0, _toConsumableArray(arrResult));
+              }
+              _exit = true;
+              return arrResult;
+            });
+          }
+        }, function (_result) {
+          return _exit ? _result : _await(fetch(jsonURL), function (resp) {
+            return _await(resp.json(), function (result) {
+              return typeof cb === 'function'
+              // eslint-disable-next-line promise/prefer-await-to-callbacks -- Old-style API
+              ? cb(result) : result;
+              // https://github.com/bcoe/c8/issues/135
+              /* c8 ignore next */
+            });
+          });
+        });
+      }, function (err) {
+        var e = /** @type {Error} */err;
+        e.message += " (File: ".concat(jsonURL, ")");
+        if (errBack) {
+          return errBack(e, jsonURL);
+        }
+        throw e;
+        // https://github.com/bcoe/c8/issues/135
+        /* c8 ignore next */
+      }));
+      /* c8 ignore next */
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
+
+var getJSON = buildGetJSONWithFetch();
+
+/**
+ * For polymorphism with Node.
+ * @returns {getJSON}
+ */
+var buildGetJSON = function buildGetJSON() {
+  return getJSON;
+};
+
+export { buildGetJSON, getJSON };
+//# sourceMappingURL=index-es.js.map

package/demo/xpath2-placeholder.js

@@ -0,0 +1 @@
+export default {};

package/dist/AbstractJoiningTransformer.d.ts

@@ -1,4 +1,76 @@
 export default AbstractJoiningTransformer;
+export type BaseTransformerConfig = {
+    requireSameChildren?: boolean;
+    JHTMLForJSON?: boolean;
+    mode?: "JSON" | "JavaScript";
+};
+/**
+ * When exposeDocuments is true, get() returns an array of XMLDocument
+ * objects (one per root element) instead of a DocumentFragment.
+ */
+export type DOMJoiningTransformerConfig = BaseTransformerConfig & {
+    document: Document;
+    exposeDocuments?: boolean;
+};
+export type JSONJoiningTransformerConfig = {
+    requireSameChildren?: boolean | undefined;
+    unwrapSingleResult?: boolean | undefined;
+    /**
+     * - When true, get() returns an array
+     * of document wrapper objects (one per root element) instead of the raw array.
+     */
+    exposeDocuments?: boolean | undefined;
+    mode?: "JSON" | "JavaScript" | undefined;
+};
+/**
+ * When exposeDocuments is true, get() returns an array of document
+ * strings (one per root element) instead of a single concatenated string.
+ */
+export type StringJoiningTransformerConfig = BaseTransformerConfig & {
+    xmlElements?: boolean;
+    preEscapedAttributes?: boolean;
+    exposeDocuments?: boolean;
+};
+export type JoiningTransformerConfig<T> = T extends "string" ? StringJoiningTransformerConfig : T extends "dom" ? DOMJoiningTransformerConfig : T extends "json" ? JSONJoiningTransformerConfig : never;
+/**
+ * @typedef {{
+ *   requireSameChildren?: boolean,
+ *   JHTMLForJSON?: boolean,
+ *   mode?: "JSON"|"JavaScript"
+ * }} BaseTransformerConfig
+ */
+/**
+ * @typedef {BaseTransformerConfig & {
+ *   document: Document,
+ *   exposeDocuments?: boolean
+ * }} DOMJoiningTransformerConfig
+ * When exposeDocuments is true, get() returns an array of XMLDocument
+ * objects (one per root element) instead of a DocumentFragment.
+ */
+/**
+ * @typedef {object} JSONJoiningTransformerConfig
+ * @property {boolean} [requireSameChildren]
+ * @property {boolean} [unwrapSingleResult]
+ * @property {boolean} [exposeDocuments] - When true, get() returns an array
+ * of document wrapper objects (one per root element) instead of the raw array.
+ * @property {"JSON"|"JavaScript"} [mode]
+ */
+/**
+ * @typedef {BaseTransformerConfig & {
+ *   xmlElements?: boolean,
+ *   preEscapedAttributes?: boolean,
+ *   exposeDocuments?: boolean
+ * }} StringJoiningTransformerConfig
+ * When exposeDocuments is true, get() returns an array of document
+ * strings (one per root element) instead of a single concatenated string.
+ */
+/**
+ * @template T
+ * @typedef {T extends "string" ? StringJoiningTransformerConfig :
+ *   T extends "dom" ? DOMJoiningTransformerConfig :
+ *   T extends "json" ? JSONJoiningTransformerConfig : never
+ * } JoiningTransformerConfig
+ */
 /**
  * Base class for joining transformers.
  *
@@ -13,18 +85,19 @@ export default AbstractJoiningTransformer;
  *   based on the current state.
  * - get(): returns the accumulated result.
  * - config(): temporarily tweak a config flag for the duration of a callback.
+ * @template T
  */
-declare class AbstractJoiningTransformer {
+declare class AbstractJoiningTransformer<T> {
     /**
-     * @param {object} [cfg] - Configuration object
+     * @param {JoiningTransformerConfig<T>} [cfg] - Configuration object
      */
-    constructor(cfg?: object);
+    constructor(cfg?: JoiningTransformerConfig<T>);
+    _cfg: JoiningTransformerConfig<T>;
     /**
-     * @param {any} [cfg] - Configuration object
+     * @param {JoiningTransformerConfig<T>} cfg - Configuration object
      * @returns {void}
      */
-    setConfig(cfg?: any): void;
-    _cfg: any;
+    setConfig(cfg: JoiningTransformerConfig<T>): void;
     /**
      * @param {string} type - Type name
      * @param {string} embedType - Embed type name
@@ -33,10 +106,11 @@ declare class AbstractJoiningTransformer {
     _requireSameChildren(type: string, embedType: string): void;
     /**
      * @param {string} prop - Configuration property name
-     * @param {*} val - Configuration property value
-     * @param {Function} [cb] - Callback function
+     * @param {any} val - Configuration property value
+     * @param {(this: AbstractJoiningTransformer<T>) => void} [cb]
+     *   Optional callback invoked with this instance
      * @returns {void}
      */
-    config(prop: string, val: any, cb?: Function): void;
+    config(prop: string, val: any, cb?: (this: AbstractJoiningTransformer<T>) => void): void;
 }
 //# sourceMappingURL=AbstractJoiningTransformer.d.ts.map

package/dist/AbstractJoiningTransformer.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"AbstractJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/AbstractJoiningTransformer.js"],"names":[],"mappings":";oCAKa;IACR,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,GAAC,YAAY,CAAA;CAC3B;;;;;0CAIS,qBAAqB,GAAG;IAChC,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;;;;;;;;;;;;;;;6CAaS,qBAAqB,GAAG;IAChC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;qCAKS,CAAC,IACD,CAAC,SAAS,QAAQ,GAAG,8BAA8B,GAC3D,CAAC,SAAS,KAAK,GAAG,2BAA2B,GAC7C,CAAC,SAAS,MAAM,GAAG,4BAA4B,GAAG,KAAK;AArC5D;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;;;;;;;GAOG;AACH;;;;;;;;GAQG;AACH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,yCAFa,CAAC;IAGZ;;OAEG;IACH,kBAFW,wBAAwB,CAAC,CAAC,CAAC,EAKrC;IADC,kCAAkE;IAGpE;;;OAGG;IACH,eAHW,wBAAwB,CAAC,CAAC,CAAC,GACzB,IAAI,CAIhB;IAED;;;;OAIG;IACH,2BAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAUhB;IAED;;;;;;OAMG;IACH,aANW,MAAM,OACN,GAAG,OACH,CAAC,IAAI,EAAE,0BAA0B,CAAC,CAAC,CAAC,KAAK,IAAI,GAE3C,IAAI,CAUhB;CACF"}

package/dist/DOMJoiningTransformer.d.ts

@@ -1,4 +1,10 @@
 export default DOMJoiningTransformer;
+export type SimpleCallback = (this: DOMJoiningTransformer) => void;
+/**
+ * @callback SimpleCallback
+ * @this {DOMJoiningTransformer}
+ * @returns {void}
+ */
 /**
  * Joining transformer that accumulates into a DOM tree.
  *
@@ -6,17 +12,24 @@ export default DOMJoiningTransformer;
  * It expects templates to build DOM nodes explicitly (e.g., via element(),
  * attribute(), and text()), though string/number/boolean will append text
  * nodes for convenience.
+ * @extends {AbstractJoiningTransformer<"dom">}
  */
-declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
+declare class DOMJoiningTransformer extends AbstractJoiningTransformer<"dom"> {
     /**
      * @param {DocumentFragment|Element} o - Initial DOM node
-     * @param {object} cfg - Configuration object
-     * @param {object} [cfg.document] - Document object
-     */
-    constructor(o: DocumentFragment | Element, cfg: {
-        document?: object | undefined;
-    });
-    _dom: DocumentFragment | Element;
+     * @param {import('./AbstractJoiningTransformer.js').
+     *   DOMJoiningTransformerConfig} cfg - Configuration object
+     */
+    constructor(o: DocumentFragment | Element, cfg: import("./AbstractJoiningTransformer.js").DOMJoiningTransformerConfig);
+    _dom: Element | DocumentFragment;
+    /** @type {XMLDocument[]} */
+    _docs: XMLDocument[];
+    /** @type {Array<{href: string, document: XMLDocument, format?: string}>} */
+    _resultDocuments: Array<{
+        href: string;
+        document: XMLDocument;
+        format?: string;
+    }>;
     /**
      * @param {Node} item
      * @returns {void}
@@ -28,35 +41,36 @@ declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
      */
     append(item: string | Node): void;
     /**
-     * @returns {DocumentFragment|Element}
+     * @returns {DocumentFragment|Element|XMLDocument[]}
      */
-    get(): DocumentFragment | Element;
+    get(): DocumentFragment | Element | XMLDocument[];
     /**
      * @param {string} prop - Property name
-     * @param {*} val - Property value
+     * @param {any} val - Property value
      * @returns {void}
      */
     propValue(prop: string, val: any): void;
     /**
-     * @param {object} obj - Object to serialize
-     * @param {Function} [cb] - Callback function.
+     * @param {Record<string, unknown>} obj - Object to serialize
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function.
      * @param {any[]} [usePropertySets] - Property sets to use
-     * @param {object} [propSets] - Additional property sets
+     * @param {Record<string, unknown>} [propSets] - Additional property sets
      * @returns {DOMJoiningTransformer}
      */
-    object(obj: object, cb?: Function, usePropertySets?: any[], propSets?: object): DOMJoiningTransformer;
+    object(obj: Record<string, unknown>, cb?: (this: DOMJoiningTransformer) => void, usePropertySets?: any[], propSets?: Record<string, unknown>): DOMJoiningTransformer;
     /**
      * @param {any[]|Element} arr
-     * @param {Function} [cb] - Callback function
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function
      * @returns {DOMJoiningTransformer}
      */
-    array(arr: any[] | Element, cb?: Function): DOMJoiningTransformer;
+    array(arr: any[] | Element, cb?: (this: DOMJoiningTransformer) => void): DOMJoiningTransformer;
     /**
      * @param {string} str - String value
-     * @param {Function} cb - Callback function (unused)
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback
+     *   function (unused)
      * @returns {DOMJoiningTransformer}
      */
-    string(str: string, cb: Function): DOMJoiningTransformer;
+    string(str: string, cb?: (this: DOMJoiningTransformer) => void): DOMJoiningTransformer;
     /**
      * @param {number} num - Number value
      * @returns {DOMJoiningTransformer}
@@ -81,17 +95,25 @@ declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
      */
     nonfiniteNumber(num: number): DOMJoiningTransformer;
     /**
-     * @param {Function} func - Function to stringify
+     * @param {(...args: any[]) => any} func - Function to stringify
+     * @returns {DOMJoiningTransformer}
+     */
+    function(func: (...args: any[]) => any): DOMJoiningTransformer;
+    /**
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} cfg
      * @returns {DOMJoiningTransformer}
      */
-    function(func: Function): DOMJoiningTransformer;
+    output(cfg: import("./StringJoiningTransformer.js").OutputConfig): DOMJoiningTransformer;
+    _outputConfig: any;
+    mediaType: string | undefined;
     /**
-     * @param {string} elName - Element name
-     * @param {object} [atts] - Attributes object
-     * @param {Function} [cb] - Callback function
+     * @param {Element|string} elName - Element name
+     * @param {Record<string, string>} [atts] - Attributes object
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function
      * @returns {DOMJoiningTransformer}
      */
-    element(elName: string, atts?: object, cb?: Function): DOMJoiningTransformer;
+    element(elName: Element | string, atts?: Record<string, string>, cb?: (this: DOMJoiningTransformer) => void): DOMJoiningTransformer;
+    root: any;
     /**
      * @param {string} name
      * @param {string} val
@@ -103,11 +125,49 @@ declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
      * @returns {DOMJoiningTransformer}
      */
     text(txt: string): DOMJoiningTransformer;
+    /**
+     * @param {string} text
+     * @returns {DOMJoiningTransformer}}
+     */
+    comment(text: string): DOMJoiningTransformer;
+    /**
+     * @param {string} target
+     * @param {string} data
+     * @returns {DOMJoiningTransformer}}
+     */
+    processingInstruction(target: string, data: string): DOMJoiningTransformer;
     /**
      * @param {string} str
      * @returns {DOMJoiningTransformer}
      */
     plainText(str: string): DOMJoiningTransformer;
+    /**
+     * Creates a new XML document and executes a callback in its context.
+     * Similar to XSLT's xsl:document, this allows templates to generate
+     * multiple output documents. The created document is pushed to this._docs
+     * and will be included in the result when exposeDocuments is true.
+     *
+     * @param {(this: DOMJoiningTransformer) => void} cb
+     *   Callback that builds the document content
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} [cfg]
+     *   Output configuration for the document (encoding, doctype, etc.)
+     * @returns {DOMJoiningTransformer}
+     */
+    document(cb: (this: DOMJoiningTransformer) => void, cfg?: import("./StringJoiningTransformer.js").OutputConfig): DOMJoiningTransformer;
+    /**
+     * Creates a new result document with metadata (href, format).
+     * Similar to XSLT's xsl:result-document, this allows templates to generate
+     * multiple output documents with associated metadata like URIs. The created
+     * document is stored in this._resultDocuments with the provided href.
+     *
+     * @param {string} href - URI/path for the result document
+     * @param {(this: DOMJoiningTransformer) => void} cb
+     *   Callback that builds the document content
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} [cfg]
+     *   Output configuration for the document (encoding, doctype, format, etc.)
+     * @returns {DOMJoiningTransformer}
+     */
+    resultDocument(href: string, cb: (this: DOMJoiningTransformer) => void, cfg?: import("./StringJoiningTransformer.js").OutputConfig): DOMJoiningTransformer;
 }
 import AbstractJoiningTransformer from './AbstractJoiningTransformer.js';
 //# sourceMappingURL=DOMJoiningTransformer.d.ts.map

package/dist/DOMJoiningTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DOMJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/DOMJoiningTransformer.js"],"names":[],"mappings":";AAGA;;;;;;;GAOG;AACH;IACE;;;;OAIG;IACH,eAJW,gBAAgB,GAAC,OAAO,OAEhC;QAAqB,QAAQ;KAC/B,EAKA;IAFC,iCAC0D;IAG5D;;;OAGG;IACH,gBAHW,IAAI,GACF,IAAI,CAIhB;IAED;;;OAGG;IACH,aAHW,MAAM,GAAC,IAAI,GACT,IAAI,CAIhB;IAED;;OAEG;IACH,OAFa,gBAAgB,GAAC,OAAO,CAIpC;IAED;;;;OAIG;IAEH,gBALW,MAAM,OACN,GAAC,GACC,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,YANW,MAAM,mCAEN,GAAG,EAAE,aACL,MAAM,GACJ,qBAAqB,CAWjC;IAED;;;;OAIG;IACH,WAJW,GAAG,EAAE,GAAC,OAAO,kBAEX,qBAAqB,CAWjC;IAED;;;;OAIG;IACH,YAJW,MAAM,iBAEJ,qBAAqB,CAMjC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,qBAAqB,CAKjC;IAED;;OAEG;IACH,QAFa,qBAAqB,CAKjC;IAED;;OAEG;IACH,aAFa,qBAAqB,CAUjC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,qBAAqB,CAUjC;IAED;;;OAGG;IACH,0BAFa,qBAAqB,CAUjC;IAED;;;;;OAKG;IACH,gBALW,MAAM,SACN,MAAM,kBAEJ,qBAAqB,CA6BjC;IAED;;;;OAIG;IACH,gBAJW,MAAM,OACN,MAAM,GACJ,qBAAqB,CASjC;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,qBAAqB,CAKjC;CACF;uCAzOsC,iCAAiC"}
+{"version":3,"file":"DOMJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/DOMJoiningTransformer.js"],"names":[],"mappings":";8DAMa,IAAI;AAHjB;;;;GAIG;AAEH;;;;;;;;GAQG;AACH;IACE;;;;OAIG;IACH,eAJW,gBAAgB,GAAC,OAAO,OACxB,OAAO,iCAAiC,EAC9C,2BAA2B,EAS/B;IALC,iCAAsD;IACtD,4BAA4B;IAC5B,OADW,WAAW,EAAE,CACT;IACf,4EAA4E;IAC5E,kBADW,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAC9C;IAG5B;;;OAGG;IACH,gBAHW,IAAI,GACF,IAAI,CAIhB;IAED;;;OAGG;IACH,aAHW,MAAM,GAAC,IAAI,GACT,IAAI,CAIhB;IAED;;OAEG;IACH,OAFa,gBAAgB,GAAC,OAAO,GAAC,WAAW,EAAE,CAOlD;IAED;;;;OAIG;IACH,gBAJW,MAAM,OACN,GAAG,GACD,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,YANW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OACvB,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,oBACrC,GAAG,EAAE,aACL,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrB,qBAAqB,CAYjC;IAED;;;;OAIG;IACH,WAJW,GAAG,EAAE,GAAC,OAAO,OACb,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GACnC,qBAAqB,CAWjC;IAED;;;;;OAKG;IACH,YALW,MAAM,OACN,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAEnC,qBAAqB,CAMjC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,qBAAqB,CAKjC;IAED;;OAEG;IACH,QAFa,qBAAqB,CAKjC;IAED;;OAEG;IACH,aAFa,qBAAqB,CAUjC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,qBAAqB,CAUjC;IAED;;;OAGG;IACH,eAHW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACrB,qBAAqB,CAUjC;IAED;;;OAGG;IACH,YAHW,OAAO,+BAA+B,EAAE,YAAY,GAClD,qBAAqB,CAUjC;IALC,mBAAwB;IAGxB,8BAA8B;IAIhC;;;;;OAKG;IACH,gBALW,OAAO,GAAC,MAAM,SACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OACtB,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GACnC,qBAAqB,CAqHjC;IA3GG,UAAkB;IA6GtB;;;;OAIG;IACH,gBAJW,MAAM,OACN,MAAM,GACJ,qBAAqB,CASjC;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,qBAAqB,CAWjC;IAED;;;;OAIG;IACH,8BAJW,MAAM,QACN,MAAM,GACJ,qBAAqB,CAcjC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;;;;;;;;;OAWG;IACH,aANW,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,QAErC,OAAO,+BAA+B,EAAE,YAAY,GAElD,qBAAqB,CA4BjC;IAED;;;;;;;;;;;;OAYG;IACH,qBAPW,MAAM,MACN,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,QAErC,OAAO,+BAA+B,EAAE,YAAY,GAElD,qBAAqB,CA2CjC;CACF;uCAhesC,iCAAiC"}