lambda-live-debugger 1.8.1 → 1.8.3

package/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js

@@ -17,7 +17,7 @@ export default function readDocType(xmlData, i){
         let exp = "";
         for(;i<xmlData.length;i++){
             if (xmlData[i] === '<' && !comment) { //Determine the tag type
-                if( hasBody && isEntity(xmlData, i)){
+                if( hasBody && hasSeq(xmlData, "!ENTITY",i)){
                     i += 7; 
                     let entityName, val;
                     [entityName, val,i] = readEntityExp(xmlData,i+1);
@@ -27,19 +27,19 @@ export default function readDocType(xmlData, i){
                             val: val
                         };
                 }
-                else if( hasBody && isElement(xmlData, i))  {
+                else if( hasBody && hasSeq(xmlData, "!ELEMENT",i))  {
                     i += 8;//Not supported
                     const {index} = readElementExp(xmlData,i+1);
                     i = index;
-                }else if( hasBody && isAttlist(xmlData, i)){
+                }else if( hasBody && hasSeq(xmlData, "!ATTLIST",i)){
                     i += 8;//Not supported
                     // const {index} = readAttlistExp(xmlData,i+1);
                     // i = index;
-                }else if( hasBody && isNotation(xmlData, i)) {
+                }else if( hasBody && hasSeq(xmlData, "!NOTATION",i)) {
                     i += 9;//Not supported
                     const {index} = readNotationExp(xmlData,i+1);
                     i = index;
-                }else if( isComment) comment = true;
+                }else if( hasSeq(xmlData, "!--",i) ) comment = true;
                 else throw new Error("Invalid DOCTYPE");
 
                 angleBracketsCount++;
@@ -188,8 +188,12 @@ function readIdentifierVal(xmlData, i, type) {
 }
 
 function readElementExp(xmlData, i) {
+    // <!ELEMENT br EMPTY>
+    // <!ELEMENT div ANY>
+    // <!ELEMENT title (#PCDATA)>
+    // <!ELEMENT book (title, author+)>
     // <!ELEMENT name (content-model)>
-
+    
     // Skip leading whitespace after <!ELEMENT
     i = skipWhitespace(xmlData, i);
 
@@ -207,24 +211,26 @@ function readElementExp(xmlData, i) {
 
     // Skip whitespace after element name
     i = skipWhitespace(xmlData, i);
-
+    let contentModel = "";
     // Expect '(' to start content model
-    if (xmlData[i] !== "(") {
-        throw new Error(`Expected '(', found "${xmlData[i]}"`);
-    }
-    i++; // Move past '('
+    if(xmlData[i] === "E" && hasSeq(xmlData, "MPTY",i)) i+=6;
+    else if(xmlData[i] === "A" && hasSeq(xmlData, "NY",i)) i+=4;
+    else if (xmlData[i] === "(") {
+        i++; // Move past '('
 
-    // Read content model
-    let contentModel = "";
-    while (i < xmlData.length && xmlData[i] !== ")") {
-        contentModel += xmlData[i];
-        i++;
-    }
+        // Read content model
+        while (i < xmlData.length && xmlData[i] !== ")") {
+            contentModel += xmlData[i];
+            i++;
+        }
+        if (xmlData[i] !== ")") {
+            throw new Error("Unterminated content model");
+        }
 
-    if (xmlData[i] !== ")") {
-        throw new Error("Unterminated content model");
+    }else{
+        throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
     }
-
+    
     return {
         elementName,
         contentModel: contentModel.trim(),
@@ -348,56 +354,11 @@ function readAttlistExp(xmlData, i) {
     }
 }
 
-function isComment(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === '-' &&
-    xmlData[i+3] === '-') return true
-    return false
-}
-function isEntity(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'E' &&
-    xmlData[i+3] === 'N' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'I' &&
-    xmlData[i+6] === 'T' &&
-    xmlData[i+7] === 'Y') return true
-    return false
-}
-function isElement(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'E' &&
-    xmlData[i+3] === 'L' &&
-    xmlData[i+4] === 'E' &&
-    xmlData[i+5] === 'M' &&
-    xmlData[i+6] === 'E' &&
-    xmlData[i+7] === 'N' &&
-    xmlData[i+8] === 'T') return true
-    return false
-}
-
-function isAttlist(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'A' &&
-    xmlData[i+3] === 'T' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'L' &&
-    xmlData[i+6] === 'I' &&
-    xmlData[i+7] === 'S' &&
-    xmlData[i+8] === 'T') return true
-    return false
-}
-function isNotation(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'N' &&
-    xmlData[i+3] === 'O' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'A' &&
-    xmlData[i+6] === 'T' &&
-    xmlData[i+7] === 'I' &&
-    xmlData[i+8] === 'O' &&
-    xmlData[i+9] === 'N') return true
-    return false
+function hasSeq(data, seq,i){
+    for(let j=0;j<seq.length;j++){
+        if(seq[j]!==data[i+j+1]) return false;
+    }
+    return true;
 }
 
 function validateEntityName(name){

package/node_modules/inquirer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inquirer",
-  "version": "12.6.0",
+  "version": "12.6.3",
   "description": "A collection of common interactive command line user interfaces.",
   "keywords": [
     "answer",
@@ -74,17 +74,16 @@
     "tsc": "tshy"
   },
   "dependencies": {
-    "@inquirer/core": "^10.1.10",
-    "@inquirer/prompts": "^7.5.0",
-    "@inquirer/type": "^3.0.6",
+    "@inquirer/core": "^10.1.13",
+    "@inquirer/prompts": "^7.5.3",
+    "@inquirer/type": "^3.0.7",
     "ansi-escapes": "^4.3.2",
     "mute-stream": "^2.0.0",
     "run-async": "^3.0.0",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.17.4",
-    "@repo/tsconfig": "workspace:*",
+    "@arethetypeswrong/cli": "^0.18.1",
     "@types/mute-stream": "^0.0.4",
     "tshy": "^3.0.2"
   },
@@ -108,5 +107,5 @@
       "optional": true
     }
   },
-  "gitHead": "238c3af2ecf5fefb9b010fda99bb3a532fa4f61a"
+  "gitHead": "dc0770cf6344140b19b2e6b82330fc51084653d1"
 }

package/node_modules/strnum/CHANGELOG.md

@@ -1,4 +1,9 @@
 
+**2.1.0 / 2025-05-01**
+- fix e-notation 
+  - to return string when invalid enotation is found. Eg `E24`
+  - to return valid number when only leading zero before e char is present
+
 **2.0.5 / 2025-02-27**
 - changes done in 1.1.2
 

package/node_modules/strnum/algo.stflow

@@ -0,0 +1,84 @@
+
+FLOW: toNumber
+input: x, options
+IF not string
+  END x
+ELSE_IF should skip
+  END x
+ELSE_IF 0
+  END 0
+ELSE_IF hex is supported AND x is hex
+  END int of x of base 16
+ELSE_IF possible e notation
+  FOLLOW: resolve enotation (x, trimmed x, options)
+ELSE
+  IF match numeric pattern
+    separate sign, leading zeros, pure number
+    IF x doesn't starts with "[+-]0."
+      END number(x)
+    IF leading zeros are not allowed 
+      IF leading zeros > 1
+        #00.1
+        END x
+      ELSE_IF leading zeros == 1 AND decimal is not adjacent to leading zeros
+        #06.5
+        #but not 0.65, .65, 6.0
+        END x
+    ELSE_IF str has only zeros
+      END 0
+    ELSE
+      parse x to number
+      IF parsed x == 0 or -0
+        END parsed x
+      ELSE_IF parsed x is eNotation
+        IF conversion to enotation is allowed
+          END parsed x
+        ELSE
+          END x
+      ELSE_IF floating number
+        IF parsed x is 0
+          END parsed x 
+        ELSE_IF parsed x == number without leading 0s
+          #0.456. 0.79000
+          END parsed x
+        ELSE_IF parsed x is negative AND == parsed x == number without leading 0s
+          END parsed x
+        ELSE
+          END x
+      ELSE_IF leading 0s are present
+        IF parsed x == x without leading 0s
+          END parsed x
+        ELSE
+          END x
+      ELSE
+        IF parsed x == x (consider sign)
+          END parsed x
+        ELSE
+          END x
+
+  ELSE
+    END x
+
+
+
+FLOW: resolve enotation
+input: x, trimmed x, options
+IF eNotation has not to be evaluated
+  END x
+IF match eNotation pattern
+  extract sign, eChar, leading zeros
+  find if eChar adjacent to leading zeros
+
+  IF leading zeros > 1 AND eChar adjacent to leading zeros
+    # 00e, -00e
+    END x
+  ELSE_IF exp is `0e`, `0.e`, `-0.e`, `-0e`
+    END number(x); 
+  ELSE_IF leading zeros are allowed but eChar is not adjacent to leading zeros
+    # -003e2
+    remove leading zeros
+    END number(x)
+  ELSE
+    END x
+ELSE
+  END x

package/node_modules/strnum/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strnum",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "description": "Parse String to Number based on configuration",
   "type": "module",
   "main": "strnum.js",

package/node_modules/strnum/strnum.js

@@ -25,23 +25,8 @@ export default function toNumber(str, options = {}){
         return parse_int(trimmedStr, 16);
     // }else if (options.oct && octRegex.test(str)) {
     //     return Number.parseInt(val, 8);
-    }else if (trimmedStr.search(/[eE]/)!== -1) { //eNotation
-        const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/); 
-        // +00.123 => [ , '+', '00', '.123', ..
-        if(notation){
-            // console.log(notation)
-            if(options.leadingZeros){ //accept with leading zeros
-                trimmedStr = (notation[1] || "") + notation[3];
-            }else{
-                if(notation[2] === "0" && notation[3][0]=== "."){ //valid number
-                }else{
-                    return str;
-                }
-            }
-            return options.eNotation ? Number(trimmedStr) : str;
-        }else{
-            return str;
-        }
+    }else if (trimmedStr.search(/.+[eE].+/)!== -1) { //eNotation
+        return resolveEnotation(str,trimmedStr,options);
     // }else if (options.parseBin && binRegex.test(str)) {
     //     return Number.parseInt(val, 2);
     }else{
@@ -49,33 +34,42 @@ export default function toNumber(str, options = {}){
         const match = numRegex.exec(trimmedStr);
         // +00.123 => [ , '+', '00', '.123', ..
         if(match){
-            const sign = match[1];
+            const sign = match[1] || "";
             const leadingZeros = match[2];
             let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
+            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.
+                str[leadingZeros.length+1] === "." 
+                : str[leadingZeros.length] === ".";
+
             //trim ending zeros for floating number
-            
-            if(!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str; //-0123
-            else if(!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str; //0123
-            else if(options.leadingZeros && leadingZeros===str) return 0; //00
-            
+            if(!options.leadingZeros //leading zeros are not allowed
+                && (leadingZeros.length > 1 
+                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))){
+                // 00, 00.3, +03.24, 03, 03.24
+                return str;
+            }
             else{//no leading zeros or leading zeros are allowed
                 const num = Number(trimmedStr);
-                const numStr = "" + num;
+                const parsedStr = String(num);
 
-                if(numStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation
+                if( num === 0 || num === -0) return num;
+                if(parsedStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation
                     if(options.eNotation) return num;
                     else return str;
                 }else if(trimmedStr.indexOf(".") !== -1){ //floating number
-                    if(numStr === "0" && (numTrimmedByZeros === "") ) return num; //0.0
-                    else if(numStr === numTrimmedByZeros) return num; //0.456. 0.79000
-                    else if( sign && numStr === "-"+numTrimmedByZeros) return num;
+                    if(parsedStr === "0") return num; //0.0
+                    else if(parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
+                    else if( parsedStr === `${sign}${numTrimmedByZeros}`) return num;
                     else return str;
                 }
                 
+                let n = leadingZeros? numTrimmedByZeros : trimmedStr;
                 if(leadingZeros){
-                    return (numTrimmedByZeros === numStr) || (sign+numTrimmedByZeros === numStr) ? num : str
+                    // -009 => -9
+                    return (n === parsedStr) || (sign+n === parsedStr) ? num : str
                 }else  {
-                    return (trimmedStr === numStr) || (trimmedStr === sign+numStr) ? num : str
+                    // +9
+                    return (n === parsedStr) || (n === sign+parsedStr) ? num : str
                 }
             }
         }else{ //non-numeric string
@@ -84,6 +78,32 @@ export default function toNumber(str, options = {}){
     }
 }
 
+const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
+function resolveEnotation(str,trimmedStr,options){
+    if(!options.eNotation) return str;
+    const notation = trimmedStr.match(eNotationRegx); 
+    if(notation){
+        let sign = notation[1] || "";
+        const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
+        const leadingZeros = notation[2];
+        const eAdjacentToLeadingZeros = sign ? // 0E.
+            str[leadingZeros.length+1] === eChar 
+            : str[leadingZeros.length] === eChar;
+
+        if(leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
+        else if(leadingZeros.length === 1 
+            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)){
+                return Number(trimmedStr);
+        }else if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros
+            //remove leading 0s
+            trimmedStr = (notation[1] || "") + notation[3];
+            return Number(trimmedStr);
+        }else return str;
+    }else{
+        return str;
+    }
+}
+
 /**
  * 
  * @param {string} numStr without leading zeros
@@ -94,7 +114,7 @@ function trimZeros(numStr){
         numStr = numStr.replace(/0+$/, ""); //remove ending zeros
         if(numStr === ".")  numStr = "0";
         else if(numStr[0] === ".")  numStr = "0"+numStr;
-        else if(numStr[numStr.length-1] === ".")  numStr = numStr.substr(0,numStr.length-1);
+        else if(numStr[numStr.length-1] === ".")  numStr = numStr.substring(0,numStr.length-1);
         return numStr;
     }
     return numStr;

package/node_modules/strnum/strnum.test.js

@@ -95,6 +95,7 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("-.006")).toEqual(-0.006);
         expect(toNumber("-6.0")).toEqual(-6);
         expect(toNumber("-06.0")).toEqual(-6);
+        expect(toNumber("+06.0")).toEqual(6);
         
         expect(toNumber("-0.0"   ,  { leadingZeros :  false})).toEqual(-0);
         expect(toNumber("-00.00",  { leadingZeros :  false})).toEqual("-00.00");
@@ -137,6 +138,13 @@ describe("Should convert all the valid numeric strings to number", () => {
 
         expect(toNumber("-1.0E2") ).toEqual(-100);
         expect(toNumber("1.0E-2")).toEqual(0.01);
+
+        expect(toNumber("E-2")).toEqual("E-2");
+        expect(toNumber("E2")).toEqual("E2");
+        expect(toNumber("0E2")).toEqual(0);
+        expect(toNumber("-0E2")).toEqual(-0);
+        expect(toNumber("00E2")).toEqual("00E2");
+        expect(toNumber("00E2",  { leadingZeros :  false})).toEqual("00E2");
     });
     
     it("should skip matching pattern", () => {

package/node_modules/strnum/test.js

@@ -0,0 +1,9 @@
+import toNumber from "./strnum.js";
+
+describe("Should convert all the valid numeric strings to number", () => {
+  it("should return undefined, null, empty string, or non-numeric as it is", () => {
+      // expect(toNumber("+ 90")).toEqual("+ 90");
+      // expect(toNumber("- 90")).toEqual("- 90");
+      expect(toNumber("-10E2")).toEqual(100);
+  });
+});

package/node_modules/yaml/browser/dist/compose/resolve-props.js

@@ -72,8 +72,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (token.source.endsWith(':'))
                     onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true);
                 anchor = token;
-                if (start === null)
-                    start = token.offset;
+                start ?? (start = token.offset);
                 atNewline = false;
                 hasSpace = false;
                 reqSpace = true;
@@ -82,8 +81,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (tag)
                     onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag');
                 tag = token;
-                if (start === null)
-                    start = token.offset;
+                start ?? (start = token.offset);
                 atNewline = false;
                 hasSpace = false;
                 reqSpace = true;

package/node_modules/yaml/browser/dist/compose/util-empty-scalar-position.js

@@ -1,7 +1,6 @@
 function emptyScalarPosition(offset, before, pos) {
     if (before) {
-        if (pos === null)
-            pos = before.length;
+        pos ?? (pos = before.length);
         for (let i = pos - 1; i >= 0; --i) {
             let st = before[i];
             switch (st.type) {

package/node_modules/yaml/browser/dist/doc/anchors.js

@@ -39,8 +39,7 @@ function createNodeAnchors(doc, prefix) {
     return {
         onAnchor: (source) => {
             aliasObjects.push(source);
-            if (!prevAnchors)
-                prevAnchors = anchorNames(doc);
+            prevAnchors ?? (prevAnchors = anchorNames(doc));
             const anchor = findNewAnchor(prefix, prevAnchors);
             prevAnchors.add(anchor);
             return anchor;

package/node_modules/yaml/browser/dist/doc/createNode.js

@@ -38,8 +38,7 @@ function createNode(value, tagName, ctx) {
     if (aliasDuplicateObjects && value && typeof value === 'object') {
         ref = sourceObjects.get(value);
         if (ref) {
-            if (!ref.anchor)
-                ref.anchor = onAnchor(value);
+            ref.anchor ?? (ref.anchor = onAnchor(value));
             return new Alias(ref.anchor);
         }
         else {

package/node_modules/yaml/browser/dist/nodes/Alias.js

@@ -1,6 +1,6 @@
 import { anchorIsValid } from '../doc/anchors.js';
 import { visit } from '../visit.js';
-import { ALIAS, isAlias, isCollection, isPair } from './identity.js';
+import { ALIAS, isAlias, isCollection, isPair, hasAnchor } from './identity.js';
 import { NodeBase } from './Node.js';
 import { toJS } from './toJS.js';
 
@@ -18,23 +18,36 @@ class Alias extends NodeBase {
      * Resolve the value of this alias within `doc`, finding the last
      * instance of the `source` anchor before this node.
      */
-    resolve(doc) {
+    resolve(doc, ctx) {
+        let nodes;
+        if (ctx?.aliasResolveCache) {
+            nodes = ctx.aliasResolveCache;
+        }
+        else {
+            nodes = [];
+            visit(doc, {
+                Node: (_key, node) => {
+                    if (isAlias(node) || hasAnchor(node))
+                        nodes.push(node);
+                }
+            });
+            if (ctx)
+                ctx.aliasResolveCache = nodes;
+        }
         let found = undefined;
-        visit(doc, {
-            Node: (_key, node) => {
-                if (node === this)
-                    return visit.BREAK;
-                if (node.anchor === this.source)
-                    found = node;
-            }
-        });
+        for (const node of nodes) {
+            if (node === this)
+                break;
+            if (node.anchor === this.source)
+                found = node;
+        }
         return found;
     }
     toJSON(_arg, ctx) {
         if (!ctx)
             return { source: this.source };
         const { anchors, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc);
+        const source = this.resolve(doc, ctx);
         if (!source) {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);

package/node_modules/yaml/browser/dist/nodes/YAMLMap.js

@@ -1,7 +1,7 @@
 import { stringifyCollection } from '../stringify/stringifyCollection.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { Collection } from './Collection.js';
-import { isPair, isScalar, MAP } from './identity.js';
+import { MAP, isPair, isScalar } from './identity.js';
 import { Pair, createPair } from './Pair.js';
 import { isScalarValue } from './Scalar.js';
 

package/node_modules/yaml/browser/dist/nodes/addPairToJSMap.js

@@ -37,6 +37,7 @@ function addPairToJSMap(ctx, map, { key, value }) {
 function stringifyKey(key, jsKey, ctx) {
     if (jsKey === null)
         return '';
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
     if (typeof jsKey !== 'object')
         return String(jsKey);
     if (isNode(key) && ctx?.doc) {

package/node_modules/yaml/browser/dist/schema/tags.js

@@ -3,8 +3,8 @@ import { nullTag } from './common/null.js';
 import { seq } from './common/seq.js';
 import { string } from './common/string.js';
 import { boolTag } from './core/bool.js';
-import { float, floatExp, floatNaN } from './core/float.js';
-import { int, intHex, intOct } from './core/int.js';
+import { floatNaN, floatExp, float } from './core/float.js';
+import { intOct, intHex, int } from './core/int.js';
 import { schema } from './core/schema.js';
 import { schema as schema$1 } from './json/schema.js';
 import { binary } from './yaml-1.1/binary.js';
@@ -13,7 +13,7 @@ import { omap } from './yaml-1.1/omap.js';
 import { pairs } from './yaml-1.1/pairs.js';
 import { schema as schema$2 } from './yaml-1.1/schema.js';
 import { set } from './yaml-1.1/set.js';
-import { timestamp, floatTime, intTime } from './yaml-1.1/timestamp.js';
+import { timestamp, intTime, floatTime } from './yaml-1.1/timestamp.js';
 
 const schemas = new Map([
     ['core', schema],

package/node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js

@@ -41,8 +41,7 @@ const binary = {
         else {
             throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
         }
-        if (!type)
-            type = Scalar.BLOCK_LITERAL;
+        type ?? (type = Scalar.BLOCK_LITERAL);
         if (type !== Scalar.QUOTE_DOUBLE) {
             const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
             const n = Math.ceil(str.length / lineWidth);

package/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js

@@ -1,5 +1,5 @@
 import { isSeq, isPair, isMap } from '../../nodes/identity.js';
-import { Pair, createPair } from '../../nodes/Pair.js';
+import { createPair, Pair } from '../../nodes/Pair.js';
 import { Scalar } from '../../nodes/Scalar.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
 

package/node_modules/yaml/browser/dist/stringify/stringify.js

@@ -68,7 +68,7 @@ function getTagObject(tags, item) {
         tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
     }
     if (!tagObj) {
-        const name = obj?.constructor?.name ?? typeof obj;
+        const name = obj?.constructor?.name ?? (obj === null ? 'null' : typeof obj);
         throw new Error(`Tag not resolved for ${name} value`);
     }
     return tagObj;
@@ -83,7 +83,7 @@ function stringifyProps(node, tagObj, { anchors, doc }) {
         anchors.add(anchor);
         props.push(`&${anchor}`);
     }
-    const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;
+    const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);
     if (tag)
         props.push(doc.directives.tagString(tag));
     return props.join(' ');
@@ -109,8 +109,7 @@ function stringify(item, ctx, onComment, onChompKeep) {
     const node = isNode(item)
         ? item
         : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });
-    if (!tagObj)
-        tagObj = getTagObject(ctx.doc.schema.tags, node);
+    tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));
     const props = stringifyProps(node, tagObj, ctx);
     if (props.length > 0)
         ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;