@traqula/core 0.0.18 → 0.0.20

package/lib/index.cjs

@@ -25,8 +25,9 @@ __export(index_exports, {
   IndirBuilder: () => IndirBuilder,
   LexerBuilder: () => LexerBuilder,
   ParserBuilder: () => ParserBuilder,
-  TransformerSubType: () => TransformerSubType,
-  TransformerType: () => TransformerType,
+  TransformerObject: () => TransformerObject,
+  TransformerSubTyped: () => TransformerSubTyped,
+  TransformerTyped: () => TransformerTyped,
   createToken: () => createToken2,
   listToIndirectionMap: () => listToIndirectionMap,
   traqulaIndentation: () => traqulaIndentation,
@@ -51,7 +52,7 @@ var AstCoreFactory = class {
     if (filtered.length === 0) {
       return this.gen();
     }
-    const first2 = filtered[0];
+    const first2 = filtered.at(0);
     const last2 = filtered.at(-1);
     return {
       sourceLocationType: "source",
@@ -1526,8 +1527,8 @@ var Promise2 = getNative_default(root_default, "Promise");
 var Promise_default = Promise2;
 
 // ../../node_modules/lodash-es/_Set.js
-var Set2 = getNative_default(root_default, "Set");
-var Set_default = Set2;
+var Set = getNative_default(root_default, "Set");
+var Set_default = Set;
 
 // ../../node_modules/lodash-es/_getTag.js
 var mapTag2 = "[object Map]";
@@ -9395,13 +9396,16 @@ var DynamicGenerator = class {
   __context = void 0;
   origSource = "";
   generatedUntil = 0;
-  expectsSpace;
+  toEnsure = [];
+  /**
+   * Should not contain empty strings
+   * @protected
+   */
   stringBuilder = [];
   constructor(rules) {
     this.rules = rules;
     for (const rule of Object.values(rules)) {
       this[rule.name] = ((input, context, args) => {
-        this.expectsSpace = false;
         this.stringBuilder.length = 0;
         this.origSource = context.origSource;
         this.generatedUntil = context?.offset ?? 0;
@@ -9426,12 +9430,15 @@ var DynamicGenerator = class {
     const generate = () => def.gImpl({
       SUBRULE: this.subrule,
       PRINT: this.print,
-      PRINT_SPACE_LEFT: this.printSpaceLeft,
+      ENSURE: this.ensure,
+      ENSURE_EITHER: this.ensureEither,
+      NEW_LINE: this.newLine,
+      HANDLE_LOC: this.handleLoc,
+      CATCHUP: this.catchup,
       PRINT_WORD: this.printWord,
       PRINT_WORDS: this.printWords,
       PRINT_ON_EMPTY: this.printOnEmpty,
-      CATCHUP: this.catchup,
-      HANDLE_LOC: this.handleLoc
+      PRINT_ON_OWN_LINE: this.printOnOwnLine
     })(ast, this.getSafeContext(), ...arg);
     if (this.factory.isLocalized(ast)) {
       this.handleLoc(ast, generate);
@@ -9469,43 +9476,82 @@ var DynamicGenerator = class {
     }
     this.generatedUntil = Math.max(this.generatedUntil, until);
   };
+  handeEnsured(toPrint) {
+    for (const callBack of this.toEnsure) {
+      callBack(toPrint);
+    }
+    this.toEnsure.length = 0;
+  }
   print = (...args) => {
-    const pureArgs = args.filter((x) => x.length > 0);
-    if (pureArgs.length > 0) {
-      const head2 = pureArgs[0];
-      if (this.expectsSpace) {
-        this.expectsSpace = false;
-        const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
-        if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
-          this.stringBuilder.push(" ");
+    const joined = args.join("");
+    this.handeEnsured(joined);
+    this.stringBuilder.push(joined);
+  };
+  doesEndWith(subsStr) {
+    const len = subsStr.length;
+    let temp = "";
+    while (temp.length < len && this.stringBuilder.length > 0) {
+      temp = this.stringBuilder.pop() + temp;
+    }
+    this.stringBuilder.push(temp);
+    return temp.endsWith(subsStr);
+  }
+  ensure = (...args) => {
+    const toEnsure = args.join("");
+    if (!this.doesEndWith(toEnsure)) {
+      this.toEnsure.push((willPrint) => {
+        if (!willPrint.startsWith(toEnsure) && !this.doesEndWith(toEnsure)) {
+          this.stringBuilder.push(toEnsure);
         }
-      }
-      const context = this.getSafeContext();
-      if (context[traqulaIndentation] && typeof context[traqulaIndentation] === "number") {
-        const indent = context[traqulaIndentation];
-        for (const str of pureArgs) {
-          const [noNl, ...postNl] = str.split("\n");
-          this.stringBuilder.push(noNl);
-          for (const subStr of postNl.map((line) => line.trimStart())) {
-            this.stringBuilder.push("\n", " ".repeat(indent));
-            if (subStr.length > 0) {
-              this.stringBuilder.push(subStr);
-            }
-          }
+      });
+    }
+  };
+  ensureEither = (...args) => {
+    if (args.length === 1) {
+      this.ensure(...args);
+    } else if (args.length > 1 && // Not already matched?
+    !args.some((subStr) => this.doesEndWith(subStr))) {
+      this.toEnsure.push((willPrint) => {
+        if (!args.some((subStr) => willPrint.startsWith(subStr)) && !args.some((subStr) => this.doesEndWith(subStr))) {
+          this.stringBuilder.push(args[0]);
         }
+      });
+    }
+  };
+  pruneEndingBlanks() {
+    let temp = "";
+    while (/^[ \t]*$/u.test(temp) && this.stringBuilder.length > 0) {
+      temp = this.stringBuilder.pop() + temp;
+    }
+    this.print(temp.trimEnd());
+  }
+  newLine = (arg) => {
+    const indentation = this.getSafeContext()[traqulaIndentation] ?? 0;
+    if (indentation === -1) {
+      return;
+    }
+    const force = arg?.force ?? false;
+    this.pruneEndingBlanks();
+    if (force) {
+      this.print("\n", " ".repeat(indentation));
+    } else {
+      let temp = "";
+      while (!temp.includes("\n") && this.stringBuilder.length > 0) {
+        temp = this.stringBuilder.pop() + temp;
+      }
+      if (/\n[ \t]*$/u.test(temp)) {
+        temp = temp.replace(/\n[ \t]*$/u, `
+${" ".repeat(indentation)}`);
+        this.print(temp);
       } else {
-        this.stringBuilder.push(...pureArgs);
+        this.print(temp, "\n", " ".repeat(indentation));
       }
     }
   };
   printWord = (...args) => {
-    this.expectsSpace = true;
-    this.print(...args);
-    this.expectsSpace = true;
-  };
-  printSpaceLeft = (...args) => {
-    this.expectsSpace = true;
+    this.ensureEither(" ", "\n");
     this.print(...args);
+    this.ensureEither(" ", "\n");
   };
   printWords = (...args) => {
     for (const arg of args) {
@@ -9513,28 +9559,13 @@ var DynamicGenerator = class {
     }
   };
   printOnEmpty = (...args) => {
-    let counter = this.stringBuilder.length - 1;
-    let onEmpty = true;
-    const isEmptyTest = /^[ \t\n]*$/u;
-    while (counter >= 0 && onEmpty) {
-      const cur = this.stringBuilder[counter];
-      const indexOfNl = cur.lastIndexOf("\n");
-      if (indexOfNl >= 0) {
-        onEmpty = isEmptyTest.test(cur.slice(indexOfNl));
-        if (onEmpty) {
-          const newVal = cur.slice(0, indexOfNl);
-          if (newVal) {
-            this.stringBuilder[counter] = cur.slice(0, indexOfNl);
-          } else {
-            this.stringBuilder.splice(counter, 1);
-          }
-        }
-        break;
-      }
-      onEmpty = isEmptyTest.test(cur);
-      counter--;
-    }
-    this.print("\n", ...args);
+    this.newLine();
+    this.print(...args);
+  };
+  printOnOwnLine = (...args) => {
+    this.newLine();
+    this.print(...args);
+    this.newLine();
   };
 };
 
@@ -9548,10 +9579,10 @@ function listToRuleDefMap(rules) {
 }
 var GeneratorBuilder = class _GeneratorBuilder {
   static create(start) {
-    if (start instanceof _GeneratorBuilder) {
-      return new _GeneratorBuilder({ ...start.rules });
+    if (Array.isArray(start)) {
+      return new _GeneratorBuilder(listToRuleDefMap(start));
     }
-    return new _GeneratorBuilder(listToRuleDefMap(start));
+    return new _GeneratorBuilder({ ...start.rules });
   }
   rules;
   constructor(startRules) {
@@ -9600,6 +9631,9 @@ var GeneratorBuilder = class _GeneratorBuilder {
     delete this.rules[ruleName];
     return this;
   }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
   /**
    * Merge this grammar GeneratorBuilder with another.
    * It is best to merge the bigger grammar with the smaller one.
@@ -9677,10 +9711,10 @@ var DynamicIndirect = class {
 // lib/indirection-builder/IndirBuilder.js
 var IndirBuilder = class _IndirBuilder {
   static create(start) {
-    if (start instanceof _IndirBuilder) {
-      return new _IndirBuilder({ ...start.rules });
+    if (Array.isArray(start)) {
+      return new _IndirBuilder(listToIndirectionMap(start));
     }
-    return new _IndirBuilder(listToIndirectionMap(start));
+    return new _IndirBuilder({ ...start.rules });
   }
   rules;
   constructor(startRules) {
@@ -9729,6 +9763,9 @@ var IndirBuilder = class _IndirBuilder {
     delete this.rules[ruleName];
     return this;
   }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
   build() {
     return new DynamicIndirect(this.rules);
   }
@@ -9958,10 +9995,10 @@ var ParserBuilder = class _ParserBuilder {
    * If a builder is provided, a new copy will be created.
    */
   static create(start) {
-    if (start instanceof _ParserBuilder) {
-      return new _ParserBuilder({ ...start.rules });
+    if (Array.isArray(start)) {
+      return new _ParserBuilder(listToRuleDefMap2(start));
     }
-    return new _ParserBuilder(listToRuleDefMap2(start));
+    return new _ParserBuilder({ ...start.rules });
   }
   rules;
   constructor(startRules) {
@@ -10010,6 +10047,9 @@ var ParserBuilder = class _ParserBuilder {
     delete this.rules[ruleName];
     return this;
   }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
   /**
    * Merge this grammar builder with another.
    * It is best to merge the bigger grammar with the smaller one.
@@ -10096,21 +10136,31 @@ ${firstError.message}`);
   }
 };
 
-// lib/Transformers.js
-var TransformerType = class {
-  clone(obj) {
-    const newObj = Object.create(Object.getPrototypeOf(obj));
-    Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
-    return newObj;
+// lib/TransformerObject.js
+var TransformerObject = class {
+  defaultContext;
+  maxStackSize = 1e6;
+  /**
+   * Creates stateless transformer.
+   * @param defaultContext
+   */
+  constructor(defaultContext = {}) {
+    this.defaultContext = defaultContext;
   }
-  safeObjectVisit(value, mapper) {
-    if (value && typeof value === "object") {
-      if (Array.isArray(value)) {
-        return value.map((x) => this.safeObjectVisit(x, mapper));
-      }
-      return mapper(value);
+  /**
+   * Function to shallow clone any type.
+   * @param obj
+   * @protected
+   */
+  clone(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
     }
-    return value;
+    const proto = Object.getPrototypeOf(obj);
+    if (proto === Object.prototype || proto === null) {
+      return { ...obj };
+    }
+    return Object.assign(Object.create(proto), obj);
   }
   /**
    * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
@@ -10122,90 +10172,228 @@ var TransformerType = class {
    *    - Default false
    */
   transformObject(startObject, mapper, preVisitor = () => ({})) {
+    const defaults2 = this.defaultContext;
+    const defaultCopyFlag = defaults2.copy ?? true;
+    const defaultContinues = defaults2.continue ?? true;
+    const defaultIgnoreKeys = defaults2.ignoreKeys;
+    const defaultShallowKeys = defaults2.shallowKeys;
+    const defaultDidShortCut = defaults2.shortcut ?? false;
     let didShortCut = false;
-    const recurse = (curObject) => {
-      const copy = this.clone(curObject);
-      const context = preVisitor(copy);
-      didShortCut = context.shortcut ?? false;
-      const continues = context.continue ?? true;
-      if (continues && !didShortCut) {
-        for (const [key, value] of Object.entries(copy)) {
-          if (didShortCut) {
-            return copy;
+    const resultWrap = { res: startObject };
+    const stack = [startObject];
+    const stackParent = [resultWrap];
+    const stackParentKey = ["res"];
+    const handleMapperOnLen = [];
+    const mapperCopyStack = [];
+    const mapperOrigStack = [];
+    const mapperParent = [];
+    const mapperParentKey = [];
+    function handleMapper() {
+      while (stack.length === handleMapperOnLen.at(-1)) {
+        handleMapperOnLen.pop();
+        const copyToMap = mapperCopyStack.pop();
+        const origToMap = mapperOrigStack.pop();
+        const parent = mapperParent.pop();
+        const parentKey = mapperParentKey.pop();
+        parent[parentKey] = mapper(copyToMap, origToMap);
+      }
+    }
+    while (stack.length > 0 && stack.length < this.maxStackSize) {
+      const curObject = stack.pop();
+      const curParent = stackParent.pop();
+      const curKey = stackParentKey.pop();
+      if (!didShortCut) {
+        if (Array.isArray(curObject)) {
+          const newArr = [...curObject];
+          handleMapperOnLen.push(stack.length);
+          mapperCopyStack.push(newArr);
+          mapperOrigStack.push(curObject);
+          mapperParent.push(curParent);
+          mapperParentKey.push(curKey);
+          for (let index = curObject.length - 1; index >= 0; index--) {
+            const val = curObject[index];
+            if (val !== null && typeof val === "object") {
+              stack.push(val);
+              stackParent.push(newArr);
+              stackParentKey.push(index.toString());
+            }
+          }
+          handleMapper();
+          continue;
+        }
+        const context = preVisitor(curObject);
+        const copyFlag = context.copy ?? defaultCopyFlag;
+        const continues = context.continue ?? defaultContinues;
+        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+        const shallowKeys = context.shallowKeys ?? defaultShallowKeys;
+        didShortCut = context.shortcut ?? defaultDidShortCut;
+        const copy = copyFlag ? this.clone(curObject) : curObject;
+        handleMapperOnLen.push(stack.length);
+        mapperCopyStack.push(copy);
+        mapperOrigStack.push(curObject);
+        mapperParent.push(curParent);
+        mapperParentKey.push(curKey);
+        if (continues && !didShortCut) {
+          for (const key in copy) {
+            if (!Object.hasOwn(copy, key)) {
+              continue;
+            }
+            const val = copy[key];
+            const onlyShallow = shallowKeys && shallowKeys?.has(key);
+            if (onlyShallow) {
+              copy[key] = this.clone(val);
+            }
+            if (ignoreKeys && ignoreKeys.has(key)) {
+              continue;
+            }
+            if (!onlyShallow && val !== null && typeof val === "object") {
+              stack.push(val);
+              stackParentKey.push(key);
+              stackParent.push(copy);
+            }
           }
-          copy[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
         }
       }
-      return mapper(copy);
-    };
-    return recurse(startObject);
+      handleMapper();
+    }
+    if (stack.length >= this.maxStackSize) {
+      throw new Error("Transform object stack overflowed");
+    }
+    handleMapper();
+    return resultWrap.res;
   }
   /**
    * Visitor that visits all objects. Visits deeper objects first.
    */
   visitObject(startObject, visitor, preVisitor = () => ({})) {
+    const defaults2 = this.defaultContext;
+    const defaultContinues = defaults2.continue ?? true;
+    const defaultIgnoreKeys = defaults2.ignoreKeys;
+    const defaultShortcut = defaults2.shortcut ?? false;
     let didShortCut = false;
-    const recurse = (curObject) => {
-      const context = preVisitor(curObject);
-      didShortCut = context.shortcut ?? false;
-      const continues = context.continue ?? true;
-      if (continues && !didShortCut) {
-        for (const value of Object.values(curObject)) {
-          if (didShortCut) {
-            return;
+    const stack = [startObject];
+    const handleVisitorOnLen = [];
+    const visitorStack = [];
+    function handleVisitor() {
+      while (stack.length === handleVisitorOnLen.at(-1)) {
+        handleVisitorOnLen.pop();
+        const toVisit = visitorStack.pop();
+        visitor(toVisit);
+      }
+    }
+    while (stack.length > 0 && stack.length < this.maxStackSize) {
+      const curObject = stack.pop();
+      if (!didShortCut) {
+        if (Array.isArray(curObject)) {
+          for (let i = curObject.length - 1; i >= 0; i--) {
+            stack.push(curObject[i]);
+          }
+          handleVisitor();
+          continue;
+        }
+        const context = preVisitor(curObject);
+        didShortCut = context.shortcut ?? defaultShortcut;
+        const continues = context.continue ?? defaultContinues;
+        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+        handleVisitorOnLen.push(stack.length);
+        visitorStack.push(curObject);
+        if (continues && !didShortCut) {
+          for (const key in curObject) {
+            if (!Object.hasOwn(curObject, key)) {
+              continue;
+            }
+            if (ignoreKeys && ignoreKeys.has(key)) {
+              continue;
+            }
+            const val = curObject[key];
+            if (val && typeof val === "object") {
+              stack.push(val);
+            }
           }
-          this.safeObjectVisit(value, (obj) => recurse(obj));
         }
       }
-      visitor(curObject);
-    };
-    recurse(startObject);
+      handleVisitor();
+    }
+    if (stack.length >= this.maxStackSize) {
+      throw new Error("Transform object stack overflowed");
+    }
+    handleVisitor();
+  }
+};
+
+// lib/TransformerTyped.js
+var TransformerTyped = class extends TransformerObject {
+  defaultNodePreVisitor;
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext);
+    this.defaultNodePreVisitor = defaultNodePreVisitor;
   }
+  /**
+   * 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 = (curObject) => {
-      const casted = curObject;
+    const transformWrapper = (copy, orig) => {
+      let ogTransform;
+      const casted = copy;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.transform;
-        if (ogFunc) {
-          return ogFunc(casted);
-        }
+        ogTransform = nodeCallBacks[casted.type]?.transform;
       }
-      return curObject;
+      return ogTransform ? ogTransform(casted, orig) : copy;
     };
-    const preTransformWrapper = (curObject) => {
+    const nodeDefaults = this.defaultNodePreVisitor;
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      let nodeContext = {};
       const casted = curObject;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
-        if (ogFunc) {
-          return ogFunc(casted);
-        }
+        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
       }
-      return {};
+      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
     };
-    return this.transformObject(startObject, transformWrapper, preTransformWrapper);
+    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 visitWrapper = (curObject) => {
+    const visitorWrapper = (curObject) => {
       const casted = curObject;
       if (casted.type) {
-        const ogFunc = nodeCallBacks[casted.type]?.visitor;
-        if (ogFunc) {
-          ogFunc(casted);
+        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) {
-        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
-        if (ogFunc) {
-          return ogFunc(casted);
-        }
+        ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        nodeContext = nodeDefaults[casted.type] ?? nodeContext;
       }
-      return {};
+      return ogPreVisit ? { ...nodeContext, ...ogPreVisit(casted) } : nodeContext;
     };
-    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+    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) => {
@@ -10226,11 +10414,24 @@ var TransformerType = class {
     recurse(currentNode);
   }
 };
-var TransformerSubType = class extends TransformerType {
+
+// lib/TransformerSubTyped.js
+var TransformerSubTyped = class extends TransformerTyped {
+  constructor(defaultContext = {}, defaultNodePreVisitor = {}) {
+    super(defaultContext, defaultNodePreVisitor);
+  }
+  /**
+   * 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 = (curObject) => {
+    const transformWrapper = (copy, orig) => {
       let ogTransform;
-      const casted = curObject;
+      const casted = copy;
       if (casted.type && casted.subType) {
         const specific = nodeSpecificCallBacks[casted.type];
         if (specific) {
@@ -10240,7 +10441,7 @@ var TransformerSubType = class extends TransformerType {
           ogTransform = nodeCallBacks[casted.type]?.transform;
         }
       }
-      return ogTransform ? ogTransform(casted) : curObject;
+      return ogTransform ? ogTransform(casted, orig) : copy;
     };
     const preVisitWrapper = (curObject) => {
       let ogPreVisit;
@@ -10254,12 +10455,13 @@ var TransformerSubType = class extends TransformerType {
           ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
         }
       }
-      return ogPreVisit ? ogPreVisit(casted) : curObject;
+      return ogPreVisit ? ogPreVisit(casted) : {};
     };
     return this.transformObject(startObject, transformWrapper, preVisitWrapper);
   }
   /**
-   * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
+   * 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) => {
@@ -10290,10 +10492,16 @@ var TransformerSubType = class extends TransformerType {
           ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
         }
       }
-      return ogPreVisit ? ogPreVisit(casted) : curObject;
+      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) => {