@traqula/core 0.0.23 → 0.0.25

package/dist/cjs/lib/transformers/TransformerSubTyped.js

@@ -1,144 +1,113 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var TransformerSubTyped_exports = {};
-__export(TransformerSubTyped_exports, {
-  TransformerSubTyped: () => TransformerSubTyped
-});
-module.exports = __toCommonJS(TransformerSubTyped_exports);
-var import_TransformerTyped = require("./TransformerTyped.js");
-class TransformerSubTyped extends import_TransformerTyped.TransformerTyped {
-  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
-    super(defaultContext, defaultNodePreVisitor);
-  }
-  clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
-    return new TransformerSubTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
-  }
-  /**
-   * Shares the functionality and first two arguments with {@link this.transformNode}.
-   * The third argument allows you to also transform based on the subType of objects.
-   * Note that when a callback for the subtype is provided, the callback for the general type is **NOT** executed.
-   * @param startObject
-   * @param nodeCallBacks
-   * @param nodeSpecificCallBacks
-   */
-  transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
-    const transformWrapper = (copy, orig) => {
-      let ogTransform;
-      const casted = copy;
-      if (casted.type && casted.subType) {
-        const specific = nodeSpecificCallBacks[casted.type];
-        if (specific) {
-          ogTransform = specific[casted.subType]?.transform;
-        }
-        if (!ogTransform) {
-          ogTransform = nodeCallBacks[casted.type]?.transform;
-        }
-      }
-      return ogTransform ? ogTransform(casted, orig) : copy;
-    };
-    const preVisitWrapper = (curObject) => {
-      let ogPreVisit;
-      const casted = curObject;
-      if (casted.type && casted.subType) {
-        const specific = nodeSpecificCallBacks[casted.type];
-        if (specific) {
-          ogPreVisit = specific[casted.subType]?.preVisitor;
-        }
-        if (!ogPreVisit) {
-          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
-        }
-      }
-      return ogPreVisit ? ogPreVisit(casted) : {};
-    };
-    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
-  }
-  /**
-   * Similar to {@link this.visitNode} but also allows you to match based on the subtype of objects.
-   * When both nodeCallBack and NodeSpecific callBack are matched, will only visit nodeSpecifCallback
-   */
-  visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
-    const visitWrapper = (curObject) => {
-      let ogTransform;
-      const casted = curObject;
-      if (casted.type && casted.subType) {
-        const specific = nodeSpecificCallBacks[casted.type];
-        if (specific) {
-          ogTransform = specific[casted.subType]?.visitor;
-        }
-        if (!ogTransform) {
-          ogTransform = nodeCallBacks[casted.type]?.visitor;
-        }
-      }
-      if (ogTransform) {
-        ogTransform(casted);
-      }
-    };
-    const preVisitWrapper = (curObject) => {
-      let ogPreVisit;
-      const casted = curObject;
-      if (casted.type && casted.subType) {
-        const specific = nodeSpecificCallBacks[casted.type];
-        if (specific) {
-          ogPreVisit = specific[casted.subType]?.preVisitor;
-        }
-        if (!ogPreVisit) {
-          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
-        }
-      }
-      return ogPreVisit ? ogPreVisit(casted) : {};
-    };
-    this.visitObject(startObject, visitWrapper, preVisitWrapper);
-  }
-  /**
-   * Similar to {@link this.traverseNodes} but also allows you to match based on the subtype of objects.
-   * @param currentNode
-   * @param traverseNode
-   * @param traverseSubNode
-   */
-  traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
-    let didShortCut = false;
-    const recurse = (curNode) => {
-      let traverser;
-      const subObj = traverseSubNode[curNode.type];
-      if (subObj) {
-        traverser = subObj[curNode.subType];
-      }
-      if (!traverser) {
-        traverser = traverseNode[curNode.type];
-      }
-      if (traverser) {
-        const { next, shortcut } = traverser(curNode);
-        didShortCut = shortcut ?? false;
-        if (!didShortCut) {
-          for (const node of next ?? []) {
-            if (didShortCut) {
-              return;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformerSubTyped = void 0;
+const TransformerTyped_js_1 = require("./TransformerTyped.js");
+class TransformerSubTyped extends TransformerTyped_js_1.TransformerTyped {
+    constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+        super(defaultContext, defaultNodePreVisitor);
+    }
+    ;
+    clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
+        return new TransformerSubTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
+    }
+    /**
+     * Transform a single node ({@link Typed}).
+     * Similar to {@link this.transformNode} but also allowing you to target the subTypes.
+     * @param startObject the object from which we will start the transformation,
+     *   potentially visiting and transforming its descendants along the way.
+     * @param nodeCallBacks a dictionary mapping the various operation types to objects optionally
+     *    containing preVisitor and transformer.
+     *    The preVisitor allows you to provide {@link TransformContext} for the current object,
+     *    altering how it will be transformed.
+     *    The transformer allows you to manipulate the copy of the current object,
+     *    and expects you to return the value that should take the current objects place.
+     * @param nodeSpecificCallBacks Same as nodeCallBacks but using an additional level of indirection to
+     *     indicate the subType.
+     * @return the result of transforming the requested descendant operations (based on the preVisitor)
+     * using a transformer that works its way back up from the descendant to the startObject.
+     */
+    transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+        const transformWrapper = (copy, orig) => {
+            let ogTransform;
+            const casted = copy;
+            if (casted.type && casted.subType) {
+                const specific = nodeSpecificCallBacks[casted.type];
+                if (specific) {
+                    ogTransform = specific[casted.subType]?.transform;
+                }
+                if (!ogTransform) {
+                    ogTransform = nodeCallBacks[casted.type]?.transform;
+                }
             }
-            recurse(node);
-          }
-        }
-      }
-    };
-    recurse(currentNode);
-  }
+            return ogTransform ? ogTransform(casted, orig) : copy;
+        };
+        const preVisitWrapper = (curObject) => {
+            let ogPreVisit;
+            const casted = curObject;
+            if (casted.type && casted.subType) {
+                const specific = nodeSpecificCallBacks[casted.type];
+                if (specific) {
+                    ogPreVisit = specific[casted.subType]?.preVisitor;
+                }
+                if (!ogPreVisit) {
+                    ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+                }
+            }
+            return ogPreVisit ? ogPreVisit(casted) : {};
+        };
+        return this.transformObject(startObject, transformWrapper, preVisitWrapper);
+    }
+    /**
+     * Visit a selected subTree given a startObject, steering the visits based on {@link Typed} nodes.
+     * Similar to {@link this.visitNode}, but also allowing you to target subTypes.
+     * Will call the preVisitor on the outer distinct, then the visitor of the special distinct,
+     * followed by the visiting the outer distinct, printing '231'.
+     * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
+     * @param startObject the object from which we will start visiting,
+     *   potentially visiting its descendants along the way.
+     * @param nodeCallBacks a dictionary mapping the various operation types to objects optionally
+     *    containing preVisitor and visitor.
+     *    The preVisitor allows you to provide {@link VisitContext} for the current object,
+     *    altering how it will be visited.
+     *    The visitor allows you to visit the object from deepest to the outermost object.
+     *    This is useful if you for example want to manipulate the objects you visit during your visits,
+     *    similar to {@link mapOperation}.
+     * @param nodeSpecificCallBacks Same as nodeCallBacks but using an additional level of indirection to
+     *     indicate the subType.
+     */
+    visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+        const visitWrapper = (curObject) => {
+            let ogTransform;
+            const casted = curObject;
+            if (casted.type && casted.subType) {
+                const specific = nodeSpecificCallBacks[casted.type];
+                if (specific) {
+                    ogTransform = specific[casted.subType]?.visitor;
+                }
+                if (!ogTransform) {
+                    ogTransform = nodeCallBacks[casted.type]?.visitor;
+                }
+            }
+            if (ogTransform) {
+                ogTransform(casted);
+            }
+        };
+        const preVisitWrapper = (curObject) => {
+            let ogPreVisit;
+            const casted = curObject;
+            if (casted.type && casted.subType) {
+                const specific = nodeSpecificCallBacks[casted.type];
+                if (specific) {
+                    ogPreVisit = specific[casted.subType]?.preVisitor;
+                }
+                if (!ogPreVisit) {
+                    ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+                }
+            }
+            return ogPreVisit ? ogPreVisit(casted) : {};
+        };
+        this.visitObject(startObject, visitWrapper, preVisitWrapper);
+    }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TransformerSubTyped
-});
+exports.TransformerSubTyped = TransformerSubTyped;
+//# sourceMappingURL=TransformerSubTyped.js.map

package/dist/cjs/lib/transformers/TransformerSubTyped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerSubTyped.js","sourceRoot":"","sources":["../../../../lib/transformers/TransformerSubTyped.ts"],"names":[],"mappings":";;;AAMA,+DAAyD;AAEzD,MAAa,mBAAyC,SAAQ,sCAAuB;IACnF,YACE,iBAAmC,EAAE,EACrC,wBAAsD,EAAE;QAExD,KAAK,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAC;IAC/C,CAAC;IAAA,CAAC;IAEc,KAAK,CACnB,oBAAsC,EAAE,EACxC,2BAAyD,EAAE;QAE3D,OAAO,IAAI,mBAAmB,CAC5B,EAAE,GAAG,IAAI,CAAC,cAAc,EAAE,GAAG,iBAAiB,EAAE,EAChD,EAAE,GAAG,IAAI,CAAC,qBAAqB,EAAE,GAAG,wBAAwB,EAAE,CAC/D,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,qBAAqB,CAC1B,WAAmB,EACnB,aAGE,EACF,qBAIK;QAEL,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAE,IAAY,EAAW,EAAE;YAC/D,IAAI,WAA4D,CAAC;YACjE,MAAM,MAAM,GAA4B,IAAI,CAAC;YAC7C,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACpD,IAAI,QAAQ,EAAE,CAAC;oBACb,WAAW,GAAG,QAAQ,CAAyB,MAAM,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;gBAC5E,CAAC;gBACD,IAAI,CAAC,WAAW,EAAE,CAAC;oBACjB,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;gBACtD,CAAC;YACH,CAAC;YACD,OAAO,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACxD,CAAC,CAAC;QACF,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAgB,EAAE;YAC1D,IAAI,UAAqD,CAAC;YAC1D,MAAM,MAAM,GAA4B,SAAS,CAAC;YAClD,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACpD,IAAI,QAAQ,EAAE,CAAC;oBACb,UAAU,GAAG,QAAQ,CAAyB,MAAM,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC;gBAC5E,CAAC;gBACD,IAAI,CAAC,UAAU,EAAE,CAAC;oBAChB,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;gBACtD,CAAC;YACH,CAAC;YACD,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,CAAC,CAAC;QACF,OAAa,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB,EAAE,eAAe,CAAC,CAAC;IACpF,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,iBAAiB,CACtB,WAAmB,EACnB,aAGE,EACF,qBAIK;QAEL,MAAM,YAAY,GAAG,CAAC,SAAiB,EAAQ,EAAE;YAC/C,IAAI,WAA8C,CAAC;YACnD,MAAM,MAAM,GAA4B,SAAS,CAAC;YAClD,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACpD,IAAI,QAAQ,EAAE,CAAC;oBACb,WAAW,GAAG,QAAQ,CAAyB,MAAM,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;gBAC1E,CAAC;gBACD,IAAI,CAAC,WAAW,EAAE,CAAC;oBACjB,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;gBACpD,CAAC;YACH,CAAC;YACD,IAAI,WAAW,EAAE,CAAC;gBAChB,WAAW,CAAC,MAAM,CAAC,CAAC;YACtB,CAAC;QACH,CAAC,CAAC;QACF,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAgB,EAAE;YAC1D,IAAI,UAAqD,CAAC;YAC1D,MAAM,MAAM,GAA4B,SAAS,CAAC;YAClD,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACpD,IAAI,QAAQ,EAAE,CAAC;oBACb,UAAU,GAAG,QAAQ,CAAyB,MAAM,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC;gBAC5E,CAAC;gBACD,IAAI,CAAC,UAAU,EAAE,CAAC;oBAChB,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;gBACtD,CAAC;YACH,CAAC;YACD,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,CAAC,CAAC;QACF,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;IAC/D,CAAC;CACF;AA3ID,kDA2IC","sourcesContent":["import type { SubTyped, Typed } from '../types.js';\nimport type {\n  TransformContext,\n  VisitContext,\n} from './TransformerObject.js';\nimport type { DefaultNodePreVisitor, Safeness, SafeWrap } from './TransformerTyped.js';\nimport { TransformerTyped } from './TransformerTyped.js';\n\nexport class TransformerSubTyped<Nodes extends Typed> extends TransformerTyped<Nodes> {\n  public constructor(\n    defaultContext: TransformContext = {},\n    defaultNodePreVisitor: DefaultNodePreVisitor<Nodes> = {},\n  ) {\n    super(defaultContext, defaultNodePreVisitor);\n  };\n\n  public override clone(\n    newDefaultContext: TransformContext = {},\n    newDefaultNodePreVisitor: DefaultNodePreVisitor<Nodes> = {},\n  ): TransformerSubTyped<Nodes> {\n    return new TransformerSubTyped(\n      { ...this.defaultContext, ...newDefaultContext },\n      { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor },\n    );\n  }\n\n  /**\n   * Transform a single node ({@link Typed}).\n   * Similar to {@link this.transformNode} but also allowing you to target the subTypes.\n   * @param startObject the object from which we will start the transformation,\n   *   potentially visiting and transforming its descendants along the way.\n   * @param nodeCallBacks a dictionary mapping the various operation types to objects optionally\n   *    containing preVisitor and transformer.\n   *    The preVisitor allows you to provide {@link TransformContext} for the current object,\n   *    altering how it will be transformed.\n   *    The transformer allows you to manipulate the copy of the current object,\n   *    and expects you to return the value that should take the current objects place.\n   * @param nodeSpecificCallBacks Same as nodeCallBacks but using an additional level of indirection to\n   *     indicate the subType.\n   * @return the result of transforming the requested descendant operations (based on the preVisitor)\n   * using a transformer that works its way back up from the descendant to the startObject.\n   */\n  public transformNodeSpecific<Safe extends Safeness = 'safe', OutType = unknown>(\n    startObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: {\n      transform?: (copy: SafeWrap<Safe, Extract<Nodes, Typed<T>>>, orig: Extract<Nodes, Typed<T>>) => unknown;\n      preVisitor?: (orig: Extract<Nodes, Typed<T>>) => TransformContext;\n    }},\n    nodeSpecificCallBacks: {[Type in Nodes['type']]?: {\n      [SubType in Extract<Nodes, SubTyped<Type>>['subType']]?: {\n        transform?: (op: SafeWrap<Safe, Extract<Nodes, SubTyped<Type, SubType>>>) => unknown;\n        preVisitor?: (op: Extract<Nodes, SubTyped<Type, SubType>>) => TransformContext;\n      }}},\n  ): Safe extends 'unsafe' ? OutType : unknown {\n    const transformWrapper = (copy: object, orig: object): unknown => {\n      let ogTransform: ((copy: any, orig: any) => unknown) | undefined;\n      const casted = <SubTyped<Nodes['type']>>copy;\n      if (casted.type && casted.subType) {\n        const specific = nodeSpecificCallBacks[casted.type];\n        if (specific) {\n          ogTransform = specific[<keyof typeof specific> casted.subType]?.transform;\n        }\n        if (!ogTransform) {\n          ogTransform = nodeCallBacks[casted.type]?.transform;\n        }\n      }\n      return ogTransform ? ogTransform(casted, orig) : copy;\n    };\n    const preVisitWrapper = (curObject: object): VisitContext => {\n      let ogPreVisit: ((node: any) => VisitContext) | undefined;\n      const casted = <SubTyped<Nodes['type']>>curObject;\n      if (casted.type && casted.subType) {\n        const specific = nodeSpecificCallBacks[casted.type];\n        if (specific) {\n          ogPreVisit = specific[<keyof typeof specific> casted.subType]?.preVisitor;\n        }\n        if (!ogPreVisit) {\n          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;\n        }\n      }\n      return ogPreVisit ? ogPreVisit(casted) : {};\n    };\n    return <any> this.transformObject(startObject, transformWrapper, preVisitWrapper);\n  }\n\n  /**\n   * Visit a selected subTree given a startObject, steering the visits based on {@link Typed} nodes.\n   * Similar to {@link this.visitNode}, but also allowing you to target subTypes.\n   * Will call the preVisitor on the outer distinct, then the visitor of the special distinct,\n   * followed by the visiting the outer distinct, printing '231'.\n   * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.\n   * @param startObject the object from which we will start visiting,\n   *   potentially visiting its descendants along the way.\n   * @param nodeCallBacks a dictionary mapping the various operation types to objects optionally\n   *    containing preVisitor and visitor.\n   *    The preVisitor allows you to provide {@link VisitContext} for the current object,\n   *    altering how it will be visited.\n   *    The visitor allows you to visit the object from deepest to the outermost object.\n   *    This is useful if you for example want to manipulate the objects you visit during your visits,\n   *    similar to {@link mapOperation}.\n   * @param nodeSpecificCallBacks Same as nodeCallBacks but using an additional level of indirection to\n   *     indicate the subType.\n   */\n  public visitNodeSpecific(\n    startObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: {\n      visitor?: (op: Extract<Nodes, Typed<T>>) => void;\n      preVisitor?: (op: Extract<Nodes, Typed<T>>) => VisitContext;\n    }},\n    nodeSpecificCallBacks: {[Type in Nodes['type']]?:\n      {[Subtype in Extract<Nodes, SubTyped<Type>>['subType']]?: {\n        visitor?: (op: Extract<Nodes, SubTyped<Type, Subtype>>) => void;\n        preVisitor?: (op: Extract<Nodes, SubTyped<Type, Subtype>>) => VisitContext;\n      }}},\n  ): void {\n    const visitWrapper = (curObject: object): void => {\n      let ogTransform: ((node: any) => void) | undefined;\n      const casted = <SubTyped<Nodes['type']>>curObject;\n      if (casted.type && casted.subType) {\n        const specific = nodeSpecificCallBacks[casted.type];\n        if (specific) {\n          ogTransform = specific[<keyof typeof specific> casted.subType]?.visitor;\n        }\n        if (!ogTransform) {\n          ogTransform = nodeCallBacks[casted.type]?.visitor;\n        }\n      }\n      if (ogTransform) {\n        ogTransform(casted);\n      }\n    };\n    const preVisitWrapper = (curObject: object): VisitContext => {\n      let ogPreVisit: ((node: any) => VisitContext) | undefined;\n      const casted = <SubTyped<Nodes['type']>>curObject;\n      if (casted.type && casted.subType) {\n        const specific = nodeSpecificCallBacks[casted.type];\n        if (specific) {\n          ogPreVisit = specific[<keyof typeof specific> casted.subType]?.preVisitor;\n        }\n        if (!ogPreVisit) {\n          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;\n        }\n      }\n      return ogPreVisit ? ogPreVisit(casted) : {};\n    };\n    this.visitObject(startObject, visitWrapper, preVisitWrapper);\n  }\n}\n"]}

package/dist/cjs/lib/transformers/TransformerTyped.js

@@ -1,123 +1,90 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var TransformerTyped_exports = {};
-__export(TransformerTyped_exports, {
-  TransformerTyped: () => TransformerTyped
-});
-module.exports = __toCommonJS(TransformerTyped_exports);
-var import_TransformerObject = require("./TransformerObject.js");
-class TransformerTyped extends import_TransformerObject.TransformerObject {
-  defaultNodePreVisitor;
-  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
-    super(defaultContext);
-    this.defaultNodePreVisitor = defaultNodePreVisitor;
-  }
-  clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
-    return new TransformerTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
-  }
-  /**
-   * Transform a single node.
-   * The transformation calls the preVisitor from starting from the startObject.
-   * The preVisitor can dictate whether transformation should be stopped.
-   * Note that stopping the transformation also prevets further copying.
-   * The transformer itself transforms object starting with the deepest one that can be visited.
-   * The transformer callback is performed on a copy of the original.
-   * @param startObject
-   * @param nodeCallBacks
-   */
-  transformNode(startObject, nodeCallBacks) {
-    const transformWrapper = (copy, orig) => {
-      let ogTransform;
-      const casted = copy;
-      if (casted.type) {
-        ogTransform = nodeCallBacks[casted.type]?.transform;
-      }
-      return ogTransform ? ogTransform(casted, orig) : copy;
-    };
-    const nodeDefaults = this.defaultNodePreVisitor;
-    const preVisitWrapper = (curObject) => {
-      let ogPreVisit;
-      let nodeContext = {};
-      const casted = curObject;
-      if (casted.type) {
-        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
-        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
-      }
-      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
-    };
-    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
-  }
-  /**
-   * Similar to {@link this.transformNode}, but without copying the startObject.
-   * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
-   * @param startObject
-   * @param nodeCallBacks
-   */
-  visitNode(startObject, nodeCallBacks) {
-    const visitorWrapper = (curObject) => {
-      const casted = curObject;
-      if (casted.type) {
-        const ogTransform = nodeCallBacks[casted.type]?.visitor;
-        if (ogTransform) {
-          ogTransform(casted);
-        }
-      }
-    };
-    const nodeDefaults = this.defaultNodePreVisitor;
-    const preVisitWrapper = (curObject) => {
-      let ogPreVisit;
-      let nodeContext = {};
-      const casted = curObject;
-      if (casted.type) {
-        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
-        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
-      }
-      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
-    };
-    return this.visitObject(startObject, visitorWrapper, preVisitWrapper);
-  }
-  /**
-   * Traverses only selected nodes as returned by the function.
-   * @param currentNode
-   * @param traverse
-   */
-  traverseNodes(currentNode, traverse) {
-    let didShortCut = false;
-    const recurse = (curNode) => {
-      const traverser = traverse[curNode.type];
-      if (traverser) {
-        const { next, shortcut } = traverser(curNode);
-        didShortCut = shortcut ?? false;
-        if (!didShortCut) {
-          for (const node of next ?? []) {
-            if (didShortCut) {
-              return;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformerTyped = void 0;
+const TransformerObject_js_1 = require("./TransformerObject.js");
+class TransformerTyped extends TransformerObject_js_1.TransformerObject {
+    defaultNodePreVisitor;
+    constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+        super(defaultContext);
+        this.defaultNodePreVisitor = defaultNodePreVisitor;
+    }
+    ;
+    clone(newDefaultContext = {}, newDefaultNodePreVisitor = {}) {
+        return new TransformerTyped({ ...this.defaultContext, ...newDefaultContext }, { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor });
+    }
+    /**
+     * Transform a single node ({@link Typed}).
+     * @param startObject the object from which we will start the transformation,
+     *   potentially visiting and transforming its descendants along the way.
+     * @param nodeCallBacks a dictionary mapping the various node types to objects optionally
+     *    containing preVisitor and transformer.
+     *    The preVisitor allows you to provide {@link TransformContext} for the current object,
+     *    altering how it will be transformed.
+     *    The transformer allows you to manipulate the copy of the current object,
+     *    and expects you to return the value that should take the current objects place.
+     * @return the result of transforming the requested descendant operations (based on the preVisitor)
+     * using a transformer that works its way back up from the descendant to the startObject.
+     */
+    transformNode(startObject, nodeCallBacks) {
+        const transformWrapper = (copy, orig) => {
+            let ogTransform;
+            const casted = copy;
+            if (casted.type) {
+                ogTransform = nodeCallBacks[casted.type]?.transform;
             }
-            recurse(node);
-          }
-        }
-      }
-    };
-    recurse(currentNode);
-  }
+            return ogTransform ? ogTransform(casted, orig) : copy;
+        };
+        const nodeDefaults = this.defaultNodePreVisitor;
+        const preVisitWrapper = (curObject) => {
+            let ogPreVisit;
+            let nodeContext = {};
+            const casted = curObject;
+            if (casted.type) {
+                ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+                nodeContext = nodeDefaults[casted.type] ?? nodeContext;
+            }
+            return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
+        };
+        return this.transformObject(startObject, transformWrapper, preVisitWrapper);
+    }
+    /**
+     * Visit a selected subTree given a startObject, steering the visits based on {@link Typed} nodes.
+     * Will first call the preVisitor on the project and notice it should not iterate on its descendants.
+     * It then visits the project, and the outermost distinct, printing '21'.
+     * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
+     * @param startObject the object from which we will start visiting,
+     *   potentially visiting its descendants along the way.
+     * @param nodeCallBacks a dictionary mapping the various operation types to objects optionally
+     *    containing preVisitor and visitor.
+     *    The preVisitor allows you to provide {@link VisitContext} for the current object,
+     *    altering how it will be visited.
+     *    The visitor allows you to visit the object from deepest to the outermost object.
+     *    This is useful if you for example want to manipulate the objects you visit during your visits,
+     *    similar to {@link this.transformNode}.
+     */
+    visitNode(startObject, nodeCallBacks) {
+        const visitorWrapper = (curObject) => {
+            const casted = curObject;
+            if (casted.type) {
+                const ogTransform = nodeCallBacks[casted.type]?.visitor;
+                if (ogTransform) {
+                    ogTransform(casted);
+                }
+            }
+        };
+        const nodeDefaults = this.defaultNodePreVisitor;
+        const preVisitWrapper = (curObject) => {
+            let ogPreVisit;
+            let nodeContext = {};
+            const casted = curObject;
+            if (casted.type) {
+                ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+                nodeContext = nodeDefaults[casted.type] ?? nodeContext;
+            }
+            return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
+        };
+        return this.visitObject(startObject, visitorWrapper, preVisitWrapper);
+    }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TransformerTyped
-});
+exports.TransformerTyped = TransformerTyped;
+//# sourceMappingURL=TransformerTyped.js.map

package/dist/cjs/lib/transformers/TransformerTyped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerTyped.js","sourceRoot":"","sources":["../../../../lib/transformers/TransformerTyped.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Typed } from '../types.js';\nimport type { TransformContext, VisitContext } from './TransformerObject.js';\nimport { TransformerObject } from './TransformerObject.js';\n\nexport type Safeness = 'safe' | 'unsafe';\nexport type SafeWrap<Safe extends Safeness, obj extends object> =\n  Safe extends 'safe' ? {[key in keyof obj]: unknown } : obj;\n\nexport type DefaultNodePreVisitor<Nodes extends Typed> = {[T in Nodes['type']]?: TransformContext };\n\nexport class TransformerTyped<Nodes extends Typed> extends TransformerObject {\n  public constructor(\n    defaultContext: TransformContext = {},\n    protected defaultNodePreVisitor: DefaultNodePreVisitor<Nodes> = {},\n  ) {\n    super(defaultContext);\n  };\n\n  public override clone(\n    newDefaultContext: TransformContext = {},\n    newDefaultNodePreVisitor: DefaultNodePreVisitor<Nodes> = {},\n  ): TransformerTyped<Nodes> {\n    return new TransformerTyped(\n      { ...this.defaultContext, ...newDefaultContext },\n      { ...this.defaultNodePreVisitor, ...newDefaultNodePreVisitor },\n    );\n  }\n\n  /**\n   * Transform a single node ({@link Typed}).\n   * @param startObject the object from which we will start the transformation,\n   *   potentially visiting and transforming its descendants along the way.\n   * @param nodeCallBacks a dictionary mapping the various node types to objects optionally\n   *    containing preVisitor and transformer.\n   *    The preVisitor allows you to provide {@link TransformContext} for the current object,\n   *    altering how it will be transformed.\n   *    The transformer allows you to manipulate the copy of the current object,\n   *    and expects you to return the value that should take the current objects place.\n   * @return the result of transforming the requested descendant operations (based on the preVisitor)\n   * using a transformer that works its way back up from the descendant to the startObject.\n   */\n  public transformNode<Safe extends Safeness = 'safe', OutType = unknown>(\n    startObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: {\n      transform?: (copy: SafeWrap<Safe, Extract<Nodes, Typed<T>>>, orig: Extract<Nodes, Typed<T>>) => unknown;\n      preVisitor?: (orig: Extract<Nodes, Typed<T>>) => TransformContext;\n    }},\n  ): Safe extends 'unsafe' ? OutType : unknown {\n    const transformWrapper = (copy: object, orig: object): unknown => {\n      let ogTransform: ((copy: any, orig: any) => unknown) | undefined;\n      const casted = <Typed<Nodes['type']>>copy;\n      if (casted.type) {\n        ogTransform = nodeCallBacks[casted.type]?.transform;\n      }\n      return ogTransform ? ogTransform(casted, orig) : copy;\n    };\n    const nodeDefaults = this.defaultNodePreVisitor;\n    const preVisitWrapper = (curObject: object): VisitContext => {\n      let ogPreVisit: ((node: any) => VisitContext) | undefined;\n      let nodeContext: VisitContext = {};\n      const casted = <Typed<Nodes['type']>>curObject;\n      if (casted.type) {\n        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;\n        nodeContext = nodeDefaults[casted.type] ?? nodeContext;\n      }\n      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;\n    };\n    return <any> this.transformObject(startObject, transformWrapper, preVisitWrapper);\n  }\n\n  /**\n   * Visit a selected subTree given a startObject, steering the visits based on {@link Typed} nodes.\n   * Will first call the preVisitor on the project and notice it should not iterate on its descendants.\n   * It then visits the project, and the outermost distinct, printing '21'.\n   * The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.\n   * @param startObject the object from which we will start visiting,\n   *   potentially visiting its descendants along the way.\n   * @param nodeCallBacks a dictionary mapping the various operation types to objects optionally\n   *    containing preVisitor and visitor.\n   *    The preVisitor allows you to provide {@link VisitContext} for the current object,\n   *    altering how it will be visited.\n   *    The visitor allows you to visit the object from deepest to the outermost object.\n   *    This is useful if you for example want to manipulate the objects you visit during your visits,\n   *    similar to {@link this.transformNode}.\n   */\n  public visitNode(\n    startObject: object,\n    nodeCallBacks: {[T in Nodes['type']]?: {\n      visitor?: (op: Extract<Nodes, Typed<T>>) => void;\n      preVisitor?: (op: Extract<Nodes, Typed<T>>) => VisitContext;\n    }},\n  ): void {\n    const visitorWrapper = (curObject: object): void => {\n      const casted = <Typed<Nodes['type']>>curObject;\n      if (casted.type) {\n        const ogTransform = nodeCallBacks[casted.type]?.visitor;\n        if (ogTransform) {\n          ogTransform(<any> casted);\n        }\n      }\n    };\n    const nodeDefaults = this.defaultNodePreVisitor;\n    const preVisitWrapper = (curObject: object): VisitContext => {\n      let ogPreVisit: ((node: any) => VisitContext) | undefined;\n      let nodeContext: VisitContext = {};\n      const casted = <Typed<Nodes['type']>>curObject;\n      if (casted.type) {\n        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;\n        nodeContext = nodeDefaults[casted.type] ?? nodeContext;\n      }\n      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;\n    };\n    return this.visitObject(startObject, visitorWrapper, preVisitWrapper);\n  }\n}\n"]}

package/dist/cjs/lib/types.js

@@ -1,16 +1,3 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../lib/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Type that is used by the Traqula core package to type raw objects/ Data Transfer Objects (DTO).\n * Enforces the presence of a type string, and that in case the subType key is present, it also be a string.\n */\nexport interface Typed<Type extends string = string> {\n  type: Type;\n  subType?: string;\n}\n\n/**\n * A {@link Typed} object that is sure to have a subType\n */\nexport interface SubTyped<Type extends string = string, SubType extends string = string> extends Typed<Type> {\n  subType: SubType;\n}\n\n/**\n * Type used by the parser and generator builders of the core Traqula package to annotate\n * the relation between AST objects and the source string.\n */\nexport interface Localized {\n  loc: SourceLocation;\n}\n\n/**\n * Wrapper type for localization,\n * can be used to state localization information about any other type (including primitive types)\n */\nexport interface Wrap<T> extends Localized {\n  val: T;\n}\n\n/**\n * A AST node. Nodes are indexable by their types.\n * When generating, the SUBRULES called should be located within the current location range.\n */\nexport interface Node extends Localized, Typed {}\n\nexport interface SourceLocationBase {\n  sourceLocationType: string;\n}\n\n/**\n * SourceLocation type that annotates that the node represents the AST representation of\n * the given range in the source string.\n */\nexport interface SourceLocationSource extends SourceLocationBase {\n  sourceLocationType: 'source';\n  start: number;\n  end: number;\n}\n\n/**\n * Similar to {@link SourceLocationSource} but also carrying the source it related too.\n * All sourceLocation nodes that are descends of this one, relate themselves to this source.\n */\nexport interface SourceLocationInlinedSource extends SourceLocationBase, Localized {\n  sourceLocationType: 'inlinedSource';\n  /**\n   * The string that will be used as the source for this node and the descends of this node.\n   * Note that the generator will print the characters from newSource[0] until start. Likewise for the suffix.\n   */\n  newSource: string;\n  /**\n   * Behavior of the current loc, after replacing the source string.\n   */\n  loc: SourceLocation;\n  /**\n   * The range that this node replaces in the context of the original source.\n   */\n  start: number;\n  end: number;\n  startOnNew: number;\n  endOnNew: number;\n}\n\n/**\n * NoStringManifestation means the node does not have a string representation.\n * For example the literal '5' has an integer type (which is an AST node),\n * but the type does not have an associated string representation.\n * When set to true, the node will not be printed, start and end are meaningless in this case.\n */\nexport interface SourceLocationNoMaterialize extends SourceLocationBase {\n  sourceLocationType: 'noMaterialize';\n}\n\n/**\n * SourceLocation type that annotates that the node has been replaced\n *   in relation to the original string by a new string.\n * It means that this node should be generated, and that the source string from start to end has been changed.\n */\nexport interface SourceLocationStringReplace extends SourceLocationBase {\n  sourceLocationType: 'stringReplace';\n  /**\n   * The string that will replace the given range in the original source.\n   */\n  newSource: string;\n  /**\n   * The start of the region in the original source string that this node replaces.\n   */\n  start: number;\n  /**\n   * The end of the region in the original source string that this node replaces.\n   */\n  end: number;\n}\n\n/**\n * SourceLocation type that annotates that the node has been replaced in relation to the original string.\n * It means that this node should be generated, and that the source string from start to end has been changed.\n */\nexport interface SourceLocationNodeReplace extends SourceLocationBase {\n  sourceLocationType: 'nodeReplace';\n  /**\n   * The start of the region in the original source string that this node replaces.\n   */\n  start: number;\n  /**\n   * The end of the region in the original source string that this node replaces.\n   */\n  end: number;\n}\n/**\n * Must have an ancestor of type {@link SourceLocationNodeReplace}\n */\nexport interface SourceLocationNodeAutoGenerate extends SourceLocationBase {\n  sourceLocationType: 'autoGenerate';\n}\n\nexport type SourceLocation =\n  // Relate yourself to the source\n  | SourceLocationSource\n  // Add a new source\n  | SourceLocationInlinedSource\n  // No not generate anything for the current node and descendants\n  | SourceLocationNoMaterialize\n  // Replace some range by a string\n  | SourceLocationStringReplace\n  // Replace this node by some autogen\n  | SourceLocationNodeReplace\n  // Auto gen current node.\n  | SourceLocationNodeAutoGenerate;\n"]}

package/dist/cjs/lib/utils.js

@@ -1,39 +1,25 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  createToken: () => createToken,
-  traqulaIndentation: () => traqulaIndentation,
-  unCapitalize: () => unCapitalize
-});
-module.exports = __toCommonJS(utils_exports);
-var import_chevrotain = require("@traqula/chevrotain");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traqulaIndentation = void 0;
+exports.unCapitalize = unCapitalize;
+exports.createToken = createToken;
+const chevrotain_1 = require("@traqula/chevrotain");
+/**
+ * Lowercase the first letter of a given string.
+ * @param str
+ */
 function unCapitalize(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1);
+    return (str.charAt(0).toLowerCase() + str.slice(1));
 }
+/**
+ * Create a token in a typesafe way necessary by the traqula core builders.
+ */
 function createToken(config) {
-  return (0, import_chevrotain.createToken)(config);
+    return (0, chevrotain_1.createToken)(config);
 }
-const traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createToken,
-  traqulaIndentation,
-  unCapitalize
-});
+/**
+ * Key that allows you to set the space based indentation of your query when generating newlines using the NEW_LINE.
+ * A value of -1 disables the generation of newlines from the NEW_LINE function
+ */
+exports.traqulaIndentation = 'When you use this string, you expect traqula to handle indentation after every newline';
+//# sourceMappingURL=utils.js.map

package/dist/cjs/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../lib/utils.ts"],"names":[],"mappings":";;;AAYA,oCAEC;AAOD,kCAEC;AAtBD,oDAA4D;AAO5D;;;GAGG;AACH,SAAgB,YAAY,CAAmB,GAAM;IACnD,OAAyB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,CAAC;AAID;;GAEG;AACH,SAAgB,WAAW,CAAsB,MAAqC;IACpF,OAAoC,IAAA,wBAAM,EAAC,MAAM,CAAC,CAAC;AACrD,CAAC;AAQD;;;GAGG;AACU,QAAA,kBAAkB,GAC7B,wFAAwF,CAAC","sourcesContent":["import type { ITokenConfig, TokenType } from '@traqula/chevrotain';\nimport { createToken as chevcT } from '@traqula/chevrotain';\n\n/**\n * Check whether the first two types overlap, if no, return the 3th argument, else the 4th.\n */\nexport type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;\n\n/**\n * Lowercase the first letter of a given string.\n * @param str\n */\nexport function unCapitalize<T extends string>(str: T): Uncapitalize<T> {\n  return <Uncapitalize<T>> (str.charAt(0).toLowerCase() + str.slice(1));\n}\n\nexport type NamedToken<Name extends string = string> = TokenType & { name: Name };\n\n/**\n * Create a token in a typesafe way necessary by the traqula core builders.\n */\nexport function createToken<Name extends string>(config: ITokenConfig & { name: Name }): NamedToken<Name> {\n  return <TokenType & { name: Name }> chevcT(config);\n}\n\n/**\n * Patch a given type by changing the value-type of a specific key in the given object type.\n */\nexport type Patch<T extends object, Patch extends {[Key in keyof T ]?: unknown }> =\n  {[Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key] };\n\n/**\n * Key that allows you to set the space based indentation of your query when generating newlines using the NEW_LINE.\n * A value of -1 disables the generation of newlines from the NEW_LINE function\n */\nexport const traqulaIndentation =\n  'When you use this string, you expect traqula to handle indentation after every newline';\n"]}