yaml 2.0.0-5 → 2.0.0-9

package/browser/dist/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,164 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+/* global Reflect, Promise */
+var extendStatics = function (d, b) {
+  extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+  };
+
+  return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+
+  function __() {
+    this.constructor = d;
+  }
+
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __generator(thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function () {
+      if (t[0] & 1) throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  },
+      f,
+      y,
+      t,
+      g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+
+        case 7:
+          op = _.ops.pop();
+
+          _.trys.pop();
+
+          continue;
+
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+
+            _.ops.push(op);
+
+            break;
+          }
+
+          if (t[2]) _.ops.pop();
+
+          _.trys.pop();
+
+          continue;
+      }
+
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator,
+      m = s && o[s],
+      i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function () {
+      if (o && i >= o.length) o = void 0;
+      return {
+        value: o && o[i++],
+        done: !o
+      };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+export { __extends, __generator, __values };

package/browser/dist/nodes/Collection.js

@@ -1,5 +1,5 @@
 import { createNode } from '../doc/createNode.js';
-import { NodeBase, isCollection, isScalar, isPair } from './Node.js';
+import { NodeBase, isNode, isPair, isCollection, isScalar } from './Node.js';
 
 function collectionFromPath(schema, path, value) {
     let v = value;
@@ -11,19 +11,14 @@ function collectionFromPath(schema, path, value) {
             v = a;
         }
         else {
-            const o = {};
-            Object.defineProperty(o, typeof k === 'symbol' ? k : String(k), {
-                value: v,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-            v = o;
+            v = new Map([[k, v]]);
         }
     }
     return createNode(v, undefined, {
-        onAnchor() {
-            throw new Error('Repeated objects are not supported here');
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
         },
         schema,
         sourceObjects: new Map()
@@ -42,6 +37,20 @@ class Collection extends NodeBase {
             writable: true
         });
     }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
     /**
      * Adds a value to the collection. For `!!map` and `!!omap` the value must
      * be a Pair instance or a `{ key, value }` object, which may not have a key
@@ -65,7 +74,8 @@ class Collection extends NodeBase {
      * Removes a value from the collection.
      * @returns `true` if the item was found and removed.
      */
-    deleteIn([key, ...rest]) {
+    deleteIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
             return this.delete(key);
         const node = this.get(key, true);
@@ -79,7 +89,8 @@ class Collection extends NodeBase {
      * scalar values from their surrounding node; to disable set `keepScalar` to
      * `true` (collections are always returned intact).
      */
-    getIn([key, ...rest], keepScalar) {
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
         const node = this.get(key, true);
         if (rest.length === 0)
             return !keepScalar && isScalar(node) ? node.value : node;
@@ -103,7 +114,8 @@ class Collection extends NodeBase {
     /**
      * Checks if the collection includes a value with the key `key`.
      */
-    hasIn([key, ...rest]) {
+    hasIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
             return this.has(key);
         const node = this.get(key, true);
@@ -113,7 +125,8 @@ class Collection extends NodeBase {
      * Sets a value in this collection. For `!!set`, `value` needs to be a
      * boolean to add/remove the item from the set.
      */
-    setIn([key, ...rest], value) {
+    setIn(path, value) {
+        const [key, ...rest] = path;
         if (rest.length === 0) {
             this.set(key, value);
         }

package/browser/dist/nodes/Node.js

@@ -36,6 +36,13 @@ class NodeBase {
     constructor(type) {
         Object.defineProperty(this, NODE_TYPE, { value: type });
     }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
 }
 
 export { ALIAS, DOC, MAP, NODE_TYPE, NodeBase, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };

package/browser/dist/nodes/Pair.js

@@ -1,7 +1,7 @@
 import { createNode } from '../doc/createNode.js';
 import { stringifyPair } from '../stringify/stringifyPair.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
-import { NODE_TYPE, PAIR } from './Node.js';
+import { NODE_TYPE, PAIR, isNode } from './Node.js';
 
 function createPair(key, value, ctx) {
     const k = createNode(key, undefined, ctx);
@@ -14,6 +14,14 @@ class Pair {
         this.key = key;
         this.value = value;
     }
+    clone(schema) {
+        let { key, value } = this;
+        if (isNode(key))
+            key = key.clone(schema);
+        if (isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
     toJSON(_, ctx) {
         const pair = ctx && ctx.mapAsMap ? new Map() : {};
         return addPairToJSMap(ctx, pair, this);

package/browser/dist/nodes/addPairToJSMap.js

@@ -1,12 +1,13 @@
 import { warn } from '../log.js';
 import { createStringifyContext } from '../stringify/stringify.js';
-import { isScalar, isSeq, isAlias, isMap, isNode } from './Node.js';
+import { isAlias, isSeq, isScalar, isMap, isNode } from './Node.js';
 import { Scalar } from './Scalar.js';
 import { toJS } from './toJS.js';
 
 const MERGE_KEY = '<<';
 function addPairToJSMap(ctx, map, { key, value }) {
     if (ctx && ctx.doc.schema.merge && isMergeKey(key)) {
+        value = isAlias(value) ? value.resolve(ctx.doc) : value;
         if (isSeq(value))
             for (const it of value.items)
                 mergeToJSMap(ctx, map, it);
@@ -52,9 +53,9 @@ const isMergeKey = (key) => key === MERGE_KEY ||
 // Keys in mapping nodes earlier in the sequence override keys specified in
 // later mapping nodes. -- http://yaml.org/type/merge.html
 function mergeToJSMap(ctx, map, value) {
-    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : null;
+    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
     if (!isMap(source))
-        throw new Error('Merge sources must be map aliases');
+        throw new Error('Merge sources must be maps or map aliases');
     const srcMap = source.toJSON(null, ctx, Map);
     for (const [key, value] of srcMap) {
         if (map instanceof Map) {

package/browser/dist/options.js

@@ -7,9 +7,11 @@
  */
 const defaultOptions = {
     intAsBigInt: false,
+    keepSourceTokens: false,
     logLevel: 'warn',
     prettyErrors: true,
     strict: true,
+    uniqueKeys: true,
     version: '1.2'
 };
 

package/browser/dist/parse/cst-scalar.js

@@ -3,10 +3,6 @@ import { resolveFlowScalar } from '../compose/resolve-flow-scalar.js';
 import { YAMLParseError } from '../errors.js';
 import { stringifyString } from '../stringify/stringifyString.js';
 
-/**
- * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
- * Otherwise, return `null`.
- */
 function resolveAsScalar(token, strict = true, onError) {
     if (token) {
         const _onError = (pos, code, message) => {
@@ -48,7 +44,7 @@ function createScalarToken(value, context) {
         implicitKey,
         indent: indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { lineWidth: -1 }
+        options: { blockQuote: true, lineWidth: -1 }
     });
     const end = (_a = context.end) !== null && _a !== void 0 ? _a : [
         { type: 'newline', offset: -1, indent, source: '\n' }
@@ -117,7 +113,7 @@ function setScalarValue(token, value, context = {}) {
         implicitKey: implicitKey || indent === null,
         indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { lineWidth: -1 }
+        options: { blockQuote: true, lineWidth: -1 }
     });
     switch (source[0]) {
         case '|':

package/browser/dist/parse/lexer.js

@@ -79,9 +79,11 @@ function isEmpty(ch) {
             return false;
     }
 }
-const invalidFlowScalarChars = [',', '[', ']', '{', '}'];
-const invalidIdentifierChars = [' ', ',', '[', ']', '{', '}', '\n', '\r', '\t'];
-const isNotIdentifierChar = (ch) => !ch || invalidIdentifierChars.includes(ch);
+const hexDigits = '0123456789ABCDEFabcdef'.split('');
+const tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split('');
+const invalidFlowScalarChars = ',[]{}'.split('');
+const invalidAnchorChars = ' ,[]{}\n\r\t'.split('');
+const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.includes(ch);
 /**
  * Splits an input string into lexical tokens, i.e. smaller strings that are
  * easily identifiable by `tokens.tokenType()`.
@@ -132,6 +134,8 @@ class Lexer {
         this.indentNext = 0;
         /** Indentation level of the current line. */
         this.indentValue = 0;
+        /** Position of the next \n character. */
+        this.lineEndPos = null;
         /** Stores the state of the lexer if reaching the end of incpomplete input */
         this.next = null;
         /** A pointer to `buffer`; the current position of the lexer. */
@@ -144,8 +148,10 @@ class Lexer {
      * @returns A generator of lexical tokens
      */
     *lex(source, incomplete = false) {
-        if (source)
+        if (source) {
             this.buffer = this.buffer ? this.buffer + source : source;
+            this.lineEndPos = null;
+        }
         this.atEnd = !incomplete;
         let next = this.next || 'stream';
         while (next && (incomplete || this.hasChars(1)))
@@ -188,7 +194,11 @@ class Lexer {
         return offset;
     }
     getLine() {
-        let end = this.buffer.indexOf('\n', this.pos);
+        let end = this.lineEndPos;
+        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
+            end = this.buffer.indexOf('\n', this.pos);
+            this.lineEndPos = end;
+        }
         if (end === -1)
             return this.atEnd ? this.buffer.substring(this.pos) : null;
         if (this.buffer[end - 1] === '\r')
@@ -201,6 +211,7 @@ class Lexer {
     setNext(state) {
         this.buffer = this.buffer.substring(this.pos);
         this.pos = 0;
+        this.lineEndPos = null;
         this.next = state;
         return null;
     }
@@ -325,7 +336,7 @@ class Lexer {
                 yield* this.pushCount(1);
                 return 'doc';
             case '*':
-                yield* this.pushUntil(isNotIdentifierChar);
+                yield* this.pushUntil(isNotAnchorChar);
                 return 'doc';
             case '"':
             case "'":
@@ -353,7 +364,7 @@ class Lexer {
         const line = this.getLine();
         if (line === null)
             return this.setNext('flow');
-        if ((indent !== -1 && indent < this.indentNext) ||
+        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
             (indent === 0 &&
                 (line.startsWith('---') || line.startsWith('...')) &&
                 isEmpty(line[3]))) {
@@ -371,8 +382,11 @@ class Lexer {
             }
         }
         let n = 0;
-        while (line[n] === ',')
-            n += (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+        while (line[n] === ',') {
+            n += yield* this.pushCount(1);
+            n += yield* this.pushSpaces(true);
+            this.flowKey = false;
+        }
         n += yield* this.pushIndicators();
         switch (line[n]) {
             case undefined:
@@ -393,7 +407,7 @@ class Lexer {
                 this.flowLevel -= 1;
                 return this.flowLevel ? 'flow' : 'doc';
             case '*':
-                yield* this.pushUntil(isNotIdentifierChar);
+                yield* this.pushUntil(isNotAnchorChar);
                 return 'flow';
             case '"':
             case "'":
@@ -431,17 +445,19 @@ class Lexer {
                 end = this.buffer.indexOf('"', end + 1);
             }
         }
-        let nl = this.buffer.indexOf('\n', this.pos);
-        if (nl !== -1 && nl < end) {
-            while (nl !== -1 && nl < end) {
+        // Only looking for newlines within the quotes
+        const qb = this.buffer.substring(0, end);
+        let nl = qb.indexOf('\n', this.pos);
+        if (nl !== -1) {
+            while (nl !== -1) {
                 const cs = this.continueScalar(nl + 1);
                 if (cs === -1)
                     break;
-                nl = this.buffer.indexOf('\n', cs);
+                nl = qb.indexOf('\n', cs);
             }
-            if (nl !== -1 && nl < end) {
+            if (nl !== -1) {
                 // this is an error caused by an unexpected unindent
-                end = nl - 1;
+                end = nl - (qb[nl - 1] === '\r' ? 2 : 1);
             }
         }
         if (end === -1) {
@@ -541,17 +557,18 @@ class Lexer {
                 end = i;
             }
             else if (isEmpty(ch)) {
-                const next = this.buffer[i + 1];
-                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
-                    break;
+                let next = this.buffer[i + 1];
                 if (ch === '\r') {
                     if (next === '\n') {
                         i += 1;
                         ch = '\n';
+                        next = this.buffer[i + 1];
                     }
                     else
                         end = i;
                 }
+                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
+                    break;
                 if (ch === '\n') {
                     const cs = this.continueScalar(i + 1);
                     if (cs === -1)
@@ -593,13 +610,11 @@ class Lexer {
     *pushIndicators() {
         switch (this.charAt(0)) {
             case '!':
-                if (this.charAt(1) === '<')
-                    return ((yield* this.pushVerbatimTag()) +
-                        (yield* this.pushSpaces(true)) +
-                        (yield* this.pushIndicators()));
-            // fallthrough
+                return ((yield* this.pushTag()) +
+                    (yield* this.pushSpaces(true)) +
+                    (yield* this.pushIndicators()));
             case '&':
-                return ((yield* this.pushUntil(isNotIdentifierChar)) +
+                return ((yield* this.pushUntil(isNotAnchorChar)) +
                     (yield* this.pushSpaces(true)) +
                     (yield* this.pushIndicators()));
             case ':':
@@ -615,12 +630,30 @@ class Lexer {
         }
         return 0;
     }
-    *pushVerbatimTag() {
-        let i = this.pos + 2;
-        let ch = this.buffer[i];
-        while (!isEmpty(ch) && ch !== '>')
-            ch = this.buffer[++i];
-        return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
+    *pushTag() {
+        if (this.charAt(1) === '<') {
+            let i = this.pos + 2;
+            let ch = this.buffer[i];
+            while (!isEmpty(ch) && ch !== '>')
+                ch = this.buffer[++i];
+            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
+        }
+        else {
+            let i = this.pos + 1;
+            let ch = this.buffer[i];
+            while (ch) {
+                if (tagChars.includes(ch))
+                    ch = this.buffer[++i];
+                else if (ch === '%' &&
+                    hexDigits.includes(this.buffer[i + 1]) &&
+                    hexDigits.includes(this.buffer[i + 2])) {
+                    ch = this.buffer[(i += 3)];
+                }
+                else
+                    break;
+            }
+            return yield* this.pushToIndex(i, false);
+        }
     }
     *pushNewline() {
         const ch = this.buffer[this.pos];