@hyperjump/json-schema 0.23.2 → 0.23.4

package/dist/json-schema-system.js

@@ -2019,9 +2019,9 @@ System.register('JsonSchema', [], (function (exports) {
 			  }
 			};
 
-			const append = curry$a((segment, pointer) => pointer + "/" + escape(segment));
+			const append = curry$a((segment, pointer) => pointer + "/" + escape$1(segment));
 
-			const escape = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
+			const escape$1 = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
 			const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
 			const computeSegment = (value, segment) => Array.isArray(value) && segment === "-" ? value.length : segment;
 
@@ -2040,7 +2040,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const isScalar = (value) => value === null || typeof value !== "object";
 
-			var lib$3 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
+			var lib$4 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
 
 			const $__value = Symbol("$__value");
 			const $__href = Symbol("$__href");
@@ -2056,7 +2056,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var reference = { cons: cons$1, isReference, href, value: value$2 };
 
-			const JsonPointer$1 = lib$3;
+			const JsonPointer$3 = lib$4;
 			const curry$9 = justCurryIt$1;
 			const { resolveUrl: resolveUrl$2, jsonTypeOf: jsonTypeOf$1 } = common$1;
 			const Reference$2 = reference;
@@ -2080,7 +2080,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const step$1 = (key, doc) => Object.freeze({
 			  ...doc,
-			  pointer: JsonPointer$1.append(key, doc.pointer),
+			  pointer: JsonPointer$3.append(key, doc.pointer),
 			  value: value$1(doc)[key]
 			});
 
@@ -2224,7 +2224,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  ], doc);
 			};
 
-			var lib$2 = {
+			var lib$3 = {
 			  entries: entries$2,
 			  map: map$3,
 			  filter: filter,
@@ -2236,6 +2236,889 @@ System.register('JsonSchema', [], (function (exports) {
 			  allValues: allValues
 			};
 
+			var moo$1 = {exports: {}};
+
+			(function (module) {
+				(function(root, factory) {
+				  if (module.exports) {
+				    module.exports = factory();
+				  } else {
+				    root.moo = factory();
+				  }
+				}(commonjsGlobal, function() {
+
+				  var hasOwnProperty = Object.prototype.hasOwnProperty;
+				  var toString = Object.prototype.toString;
+				  var hasSticky = typeof new RegExp().sticky === 'boolean';
+
+				  /***************************************************************************/
+
+				  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }
+				  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }
+
+				  function reEscape(s) {
+				    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
+				  }
+				  function reGroups(s) {
+				    var re = new RegExp('|' + s);
+				    return re.exec('').length - 1
+				  }
+				  function reCapture(s) {
+				    return '(' + s + ')'
+				  }
+				  function reUnion(regexps) {
+				    if (!regexps.length) return '(?!)'
+				    var source =  regexps.map(function(s) {
+				      return "(?:" + s + ")"
+				    }).join('|');
+				    return "(?:" + source + ")"
+				  }
+
+				  function regexpOrLiteral(obj) {
+				    if (typeof obj === 'string') {
+				      return '(?:' + reEscape(obj) + ')'
+
+				    } else if (isRegExp(obj)) {
+				      // TODO: consider /u support
+				      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')
+				      if (obj.global) throw new Error('RegExp /g flag is implied')
+				      if (obj.sticky) throw new Error('RegExp /y flag is implied')
+				      if (obj.multiline) throw new Error('RegExp /m flag is implied')
+				      return obj.source
+
+				    } else {
+				      throw new Error('Not a pattern: ' + obj)
+				    }
+				  }
+
+				  function pad(s, length) {
+				    if (s.length > length) {
+				      return s
+				    }
+				    return Array(length - s.length + 1).join(" ") + s
+				  }
+
+				  function lastNLines(string, numLines) {
+				    var position = string.length;
+				    var lineBreaks = 0;
+				    while (true) {
+				      var idx = string.lastIndexOf("\n", position - 1);
+				      if (idx === -1) {
+				        break;
+				      } else {
+				        lineBreaks++;
+				      }
+				      position = idx;
+				      if (lineBreaks === numLines) {
+				        break;
+				      }
+				      if (position === 0) {
+				        break;
+				      }
+				    }
+				    var startPosition = 
+				      lineBreaks < numLines ?
+				      0 : 
+				      position + 1;
+				    return string.substring(startPosition).split("\n")
+				  }
+
+				  function objectToRules(object) {
+				    var keys = Object.getOwnPropertyNames(object);
+				    var result = [];
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      var thing = object[key];
+				      var rules = [].concat(thing);
+				      if (key === 'include') {
+				        for (var j = 0; j < rules.length; j++) {
+				          result.push({include: rules[j]});
+				        }
+				        continue
+				      }
+				      var match = [];
+				      rules.forEach(function(rule) {
+				        if (isObject(rule)) {
+				          if (match.length) result.push(ruleOptions(key, match));
+				          result.push(ruleOptions(key, rule));
+				          match = [];
+				        } else {
+				          match.push(rule);
+				        }
+				      });
+				      if (match.length) result.push(ruleOptions(key, match));
+				    }
+				    return result
+				  }
+
+				  function arrayToRules(array) {
+				    var result = [];
+				    for (var i = 0; i < array.length; i++) {
+				      var obj = array[i];
+				      if (obj.include) {
+				        var include = [].concat(obj.include);
+				        for (var j = 0; j < include.length; j++) {
+				          result.push({include: include[j]});
+				        }
+				        continue
+				      }
+				      if (!obj.type) {
+				        throw new Error('Rule has no type: ' + JSON.stringify(obj))
+				      }
+				      result.push(ruleOptions(obj.type, obj));
+				    }
+				    return result
+				  }
+
+				  function ruleOptions(type, obj) {
+				    if (!isObject(obj)) {
+				      obj = { match: obj };
+				    }
+				    if (obj.include) {
+				      throw new Error('Matching rules cannot also include states')
+				    }
+
+				    // nb. error and fallback imply lineBreaks
+				    var options = {
+				      defaultType: type,
+				      lineBreaks: !!obj.error || !!obj.fallback,
+				      pop: false,
+				      next: null,
+				      push: null,
+				      error: false,
+				      fallback: false,
+				      value: null,
+				      type: null,
+				      shouldThrow: false,
+				    };
+
+				    // Avoid Object.assign(), so we support IE9+
+				    for (var key in obj) {
+				      if (hasOwnProperty.call(obj, key)) {
+				        options[key] = obj[key];
+				      }
+				    }
+
+				    // type transform cannot be a string
+				    if (typeof options.type === 'string' && type !== options.type) {
+				      throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')")
+				    }
+
+				    // convert to array
+				    var match = options.match;
+				    options.match = Array.isArray(match) ? match : match ? [match] : [];
+				    options.match.sort(function(a, b) {
+				      return isRegExp(a) && isRegExp(b) ? 0
+				           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length
+				    });
+				    return options
+				  }
+
+				  function toRules(spec) {
+				    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)
+				  }
+
+				  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true});
+				  function compileRules(rules, hasStates) {
+				    var errorRule = null;
+				    var fast = Object.create(null);
+				    var fastAllowed = true;
+				    var unicodeFlag = null;
+				    var groups = [];
+				    var parts = [];
+
+				    // If there is a fallback rule, then disable fast matching
+				    for (var i = 0; i < rules.length; i++) {
+				      if (rules[i].fallback) {
+				        fastAllowed = false;
+				      }
+				    }
+
+				    for (var i = 0; i < rules.length; i++) {
+				      var options = rules[i];
+
+				      if (options.include) {
+				        // all valid inclusions are removed by states() preprocessor
+				        throw new Error('Inheritance is not allowed in stateless lexers')
+				      }
+
+				      if (options.error || options.fallback) {
+				        // errorRule can only be set once
+				        if (errorRule) {
+				          if (!options.fallback === !errorRule.fallback) {
+				            throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')")
+				          } else {
+				            throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')")
+				          }
+				        }
+				        errorRule = options;
+				      }
+
+				      var match = options.match.slice();
+				      if (fastAllowed) {
+				        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {
+				          var word = match.shift();
+				          fast[word.charCodeAt(0)] = options;
+				        }
+				      }
+
+				      // Warn about inappropriate state-switching options
+				      if (options.pop || options.push || options.next) {
+				        if (!hasStates) {
+				          throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')")
+				        }
+				        if (options.fallback) {
+				          throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')")
+				        }
+				      }
+
+				      // Only rules with a .match are included in the RegExp
+				      if (match.length === 0) {
+				        continue
+				      }
+				      fastAllowed = false;
+
+				      groups.push(options);
+
+				      // Check unicode flag is used everywhere or nowhere
+				      for (var j = 0; j < match.length; j++) {
+				        var obj = match[j];
+				        if (!isRegExp(obj)) {
+				          continue
+				        }
+
+				        if (unicodeFlag === null) {
+				          unicodeFlag = obj.unicode;
+				        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
+				          throw new Error('If one rule is /u then all must be')
+				        }
+				      }
+
+				      // convert to RegExp
+				      var pat = reUnion(match.map(regexpOrLiteral));
+
+				      // validate
+				      var regexp = new RegExp(pat);
+				      if (regexp.test("")) {
+				        throw new Error("RegExp matches empty string: " + regexp)
+				      }
+				      var groupCount = reGroups(pat);
+				      if (groupCount > 0) {
+				        throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: … ) instead")
+				      }
+
+				      // try and detect rules matching newlines
+				      if (!options.lineBreaks && regexp.test('\n')) {
+				        throw new Error('Rule should declare lineBreaks: ' + regexp)
+				      }
+
+				      // store regex
+				      parts.push(reCapture(pat));
+				    }
+
+
+				    // If there's no fallback rule, use the sticky flag so we only look for
+				    // matches at the current index.
+				    //
+				    // If we don't support the sticky flag, then fake it using an irrefutable
+				    // match (i.e. an empty pattern).
+				    var fallbackRule = errorRule && errorRule.fallback;
+				    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm';
+				    var suffix = hasSticky || fallbackRule ? '' : '|';
+
+				    if (unicodeFlag === true) flags += "u";
+				    var combined = new RegExp(reUnion(parts) + suffix, flags);
+				    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}
+				  }
+
+				  function compile(rules) {
+				    var result = compileRules(toRules(rules));
+				    return new Lexer({start: result}, 'start')
+				  }
+
+				  function checkStateGroup(g, name, map) {
+				    var state = g && (g.push || g.next);
+				    if (state && !map[state]) {
+				      throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')")
+				    }
+				    if (g && g.pop && +g.pop !== 1) {
+				      throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')")
+				    }
+				  }
+				  function compileStates(states, start) {
+				    var all = states.$all ? toRules(states.$all) : [];
+				    delete states.$all;
+
+				    var keys = Object.getOwnPropertyNames(states);
+				    if (!start) start = keys[0];
+
+				    var ruleMap = Object.create(null);
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      ruleMap[key] = toRules(states[key]).concat(all);
+				    }
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      var rules = ruleMap[key];
+				      var included = Object.create(null);
+				      for (var j = 0; j < rules.length; j++) {
+				        var rule = rules[j];
+				        if (!rule.include) continue
+				        var splice = [j, 1];
+				        if (rule.include !== key && !included[rule.include]) {
+				          included[rule.include] = true;
+				          var newRules = ruleMap[rule.include];
+				          if (!newRules) {
+				            throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')")
+				          }
+				          for (var k = 0; k < newRules.length; k++) {
+				            var newRule = newRules[k];
+				            if (rules.indexOf(newRule) !== -1) continue
+				            splice.push(newRule);
+				          }
+				        }
+				        rules.splice.apply(rules, splice);
+				        j--;
+				      }
+				    }
+
+				    var map = Object.create(null);
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      map[key] = compileRules(ruleMap[key], true);
+				    }
+
+				    for (var i = 0; i < keys.length; i++) {
+				      var name = keys[i];
+				      var state = map[name];
+				      var groups = state.groups;
+				      for (var j = 0; j < groups.length; j++) {
+				        checkStateGroup(groups[j], name, map);
+				      }
+				      var fastKeys = Object.getOwnPropertyNames(state.fast);
+				      for (var j = 0; j < fastKeys.length; j++) {
+				        checkStateGroup(state.fast[fastKeys[j]], name, map);
+				      }
+				    }
+
+				    return new Lexer(map, start)
+				  }
+
+				  function keywordTransform(map) {
+
+				    // Use a JavaScript Map to map keywords to their corresponding token type
+				    // unless Map is unsupported, then fall back to using an Object:
+				    var isMap = typeof Map !== 'undefined';
+				    var reverseMap = isMap ? new Map : Object.create(null);
+
+				    var types = Object.getOwnPropertyNames(map);
+				    for (var i = 0; i < types.length; i++) {
+				      var tokenType = types[i];
+				      var item = map[tokenType];
+				      var keywordList = Array.isArray(item) ? item : [item];
+				      keywordList.forEach(function(keyword) {
+				        if (typeof keyword !== 'string') {
+				          throw new Error("keyword must be string (in keyword '" + tokenType + "')")
+				        }
+				        if (isMap) {
+				          reverseMap.set(keyword, tokenType);
+				        } else {
+				          reverseMap[keyword] = tokenType;
+				        }
+				      });
+				    }
+				    return function(k) {
+				      return isMap ? reverseMap.get(k) : reverseMap[k]
+				    }
+				  }
+
+				  /***************************************************************************/
+
+				  var Lexer = function(states, state) {
+				    this.startState = state;
+				    this.states = states;
+				    this.buffer = '';
+				    this.stack = [];
+				    this.reset();
+				  };
+
+				  Lexer.prototype.reset = function(data, info) {
+				    this.buffer = data || '';
+				    this.index = 0;
+				    this.line = info ? info.line : 1;
+				    this.col = info ? info.col : 1;
+				    this.queuedToken = info ? info.queuedToken : null;
+				    this.queuedText = info ? info.queuedText: "";
+				    this.queuedThrow = info ? info.queuedThrow : null;
+				    this.setState(info ? info.state : this.startState);
+				    this.stack = info && info.stack ? info.stack.slice() : [];
+				    return this
+				  };
+
+				  Lexer.prototype.save = function() {
+				    return {
+				      line: this.line,
+				      col: this.col,
+				      state: this.state,
+				      stack: this.stack.slice(),
+				      queuedToken: this.queuedToken,
+				      queuedText: this.queuedText,
+				      queuedThrow: this.queuedThrow,
+				    }
+				  };
+
+				  Lexer.prototype.setState = function(state) {
+				    if (!state || this.state === state) return
+				    this.state = state;
+				    var info = this.states[state];
+				    this.groups = info.groups;
+				    this.error = info.error;
+				    this.re = info.regexp;
+				    this.fast = info.fast;
+				  };
+
+				  Lexer.prototype.popState = function() {
+				    this.setState(this.stack.pop());
+				  };
+
+				  Lexer.prototype.pushState = function(state) {
+				    this.stack.push(this.state);
+				    this.setState(state);
+				  };
+
+				  var eat = hasSticky ? function(re, buffer) { // assume re is /y
+				    return re.exec(buffer)
+				  } : function(re, buffer) { // assume re is /g
+				    var match = re.exec(buffer);
+				    // will always match, since we used the |(?:) trick
+				    if (match[0].length === 0) {
+				      return null
+				    }
+				    return match
+				  };
+
+				  Lexer.prototype._getGroup = function(match) {
+				    var groupCount = this.groups.length;
+				    for (var i = 0; i < groupCount; i++) {
+				      if (match[i + 1] !== undefined) {
+				        return this.groups[i]
+				      }
+				    }
+				    throw new Error('Cannot find token type for matched text')
+				  };
+
+				  function tokenToString() {
+				    return this.value
+				  }
+
+				  Lexer.prototype.next = function() {
+				    var index = this.index;
+
+				    // If a fallback token matched, we don't need to re-run the RegExp
+				    if (this.queuedGroup) {
+				      var token = this._token(this.queuedGroup, this.queuedText, index);
+				      this.queuedGroup = null;
+				      this.queuedText = "";
+				      return token
+				    }
+
+				    var buffer = this.buffer;
+				    if (index === buffer.length) {
+				      return // EOF
+				    }
+
+				    // Fast matching for single characters
+				    var group = this.fast[buffer.charCodeAt(index)];
+				    if (group) {
+				      return this._token(group, buffer.charAt(index), index)
+				    }
+
+				    // Execute RegExp
+				    var re = this.re;
+				    re.lastIndex = index;
+				    var match = eat(re, buffer);
+
+				    // Error tokens match the remaining buffer
+				    var error = this.error;
+				    if (match == null) {
+				      return this._token(error, buffer.slice(index, buffer.length), index)
+				    }
+
+				    var group = this._getGroup(match);
+				    var text = match[0];
+
+				    if (error.fallback && match.index !== index) {
+				      this.queuedGroup = group;
+				      this.queuedText = text;
+
+				      // Fallback tokens contain the unmatched portion of the buffer
+				      return this._token(error, buffer.slice(index, match.index), index)
+				    }
+
+				    return this._token(group, text, index)
+				  };
+
+				  Lexer.prototype._token = function(group, text, offset) {
+				    // count line breaks
+				    var lineBreaks = 0;
+				    if (group.lineBreaks) {
+				      var matchNL = /\n/g;
+				      var nl = 1;
+				      if (text === '\n') {
+				        lineBreaks = 1;
+				      } else {
+				        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex; }
+				      }
+				    }
+
+				    var token = {
+				      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,
+				      value: typeof group.value === 'function' ? group.value(text) : text,
+				      text: text,
+				      toString: tokenToString,
+				      offset: offset,
+				      lineBreaks: lineBreaks,
+				      line: this.line,
+				      col: this.col,
+				    };
+				    // nb. adding more props to token object will make V8 sad!
+
+				    var size = text.length;
+				    this.index += size;
+				    this.line += lineBreaks;
+				    if (lineBreaks !== 0) {
+				      this.col = size - nl + 1;
+				    } else {
+				      this.col += size;
+				    }
+
+				    // throw, if no rule with {error: true}
+				    if (group.shouldThrow) {
+				      var err = new Error(this.formatError(token, "invalid syntax"));
+				      throw err;
+				    }
+
+				    if (group.pop) this.popState();
+				    else if (group.push) this.pushState(group.push);
+				    else if (group.next) this.setState(group.next);
+
+				    return token
+				  };
+
+				  if (typeof Symbol !== 'undefined' && Symbol.iterator) {
+				    var LexerIterator = function(lexer) {
+				      this.lexer = lexer;
+				    };
+
+				    LexerIterator.prototype.next = function() {
+				      var token = this.lexer.next();
+				      return {value: token, done: !token}
+				    };
+
+				    LexerIterator.prototype[Symbol.iterator] = function() {
+				      return this
+				    };
+
+				    Lexer.prototype[Symbol.iterator] = function() {
+				      return new LexerIterator(this)
+				    };
+				  }
+
+				  Lexer.prototype.formatError = function(token, message) {
+				    if (token == null) {
+				      // An undefined token indicates EOF
+				      var text = this.buffer.slice(this.index);
+				      var token = {
+				        text: text,
+				        offset: this.index,
+				        lineBreaks: text.indexOf('\n') === -1 ? 0 : 1,
+				        line: this.line,
+				        col: this.col,
+				      };
+				    }
+				    
+				    var numLinesAround = 2;
+				    var firstDisplayedLine = Math.max(token.line - numLinesAround, 1);
+				    var lastDisplayedLine = token.line + numLinesAround;
+				    var lastLineDigits = String(lastDisplayedLine).length;
+				    var displayedLines = lastNLines(
+				        this.buffer, 
+				        (this.line - token.line) + numLinesAround + 1
+				      )
+				      .slice(0, 5);
+				    var errorLines = [];
+				    errorLines.push(message + " at line " + token.line + " col " + token.col + ":");
+				    errorLines.push("");
+				    for (var i = 0; i < displayedLines.length; i++) {
+				      var line = displayedLines[i];
+				      var lineNo = firstDisplayedLine + i;
+				      errorLines.push(pad(String(lineNo), lastLineDigits) + "  " + line);
+				      if (lineNo === token.line) {
+				        errorLines.push(pad("", lastLineDigits + token.col + 1) + "^");
+				      }
+				    }
+				    return errorLines.join("\n")
+				  };
+
+				  Lexer.prototype.clone = function() {
+				    return new Lexer(this.states, this.state)
+				  };
+
+				  Lexer.prototype.has = function(tokenType) {
+				    return true
+				  };
+
+
+				  return {
+				    compile: compile,
+				    states: compileStates,
+				    error: Object.freeze({error: true}),
+				    fallback: Object.freeze({fallback: true}),
+				    keywords: keywordTransform,
+				  }
+
+				}));
+			} (moo$1));
+
+			const moo = moo$1.exports;
+
+
+			const digit = `[0-9]`;
+			const digit19 = `[1-9]`;
+			const hexdig = `[0-9a-fA-F]`;
+
+			// String
+			const unescaped = `[\\x20-\\x21\\x23-\\x5b\\x5d-\\u{10ffff}]`;
+			const escape = `\\\\`;
+			const escaped = `${escape}(?:["\\/\\\\brfnt]|u${hexdig}{4})`;
+			const char = `(?:${unescaped}|${escaped})`;
+			const string = `"${char}*"`;
+
+			// Number
+			const int = `(?:0|${digit19}${digit}*)`;
+			const frac = `\\.${digit}+`;
+			const e = `[eE]`;
+			const exp = `${e}[-+]?${digit}+`;
+			const number = `-?${int}(?:${frac})?(?:${exp})?`;
+
+			// Whitespace
+			const whitespace = `(?:(?:\\r?\\n)|[ \\t])+`;
+
+			var lexer = (json) => {
+			  const lexer = moo.states({
+			    main: {
+			      WS: { match: new RegExp(whitespace, "u"), lineBreaks: true },
+			      true: { match: "true", value: () => true },
+			      false: { match: "false", value: () => false },
+			      null: { match: "null", value: () => null },
+			      number: { match: new RegExp(number, "u"), value: parseFloat },
+			      string: { match: new RegExp(string, "u"), value: JSON.parse },
+			      "{": "{",
+			      "}": "}",
+			      "[": "[",
+			      "]": "]",
+			      ":": ":",
+			      ",": ",",
+			      error: moo.error
+			    }
+			  });
+			  lexer.reset(json);
+
+			  const _next = () => {
+			    let token;
+			    do {
+			      token = lexer.next();
+			      if (token?.type === "error") {
+			        throw SyntaxError(lexer.formatError(token, "Unrecognized token"));
+			      }
+			    } while (token?.type === "WS");
+
+			    return token;
+			  };
+
+			  let previous;
+			  let nextToken = _next();
+
+			  const next = (expectedType = undefined) => {
+			    previous = nextToken;
+			    nextToken = _next();
+			    if (expectedType && previous?.type !== expectedType) {
+			      throw SyntaxError(lexer.formatError(previous, `Expected a '${expectedType}'`));
+			    }
+			    return previous;
+			  };
+
+			  const peek = () => nextToken;
+
+			  const defaultErrorToken = { offset: 0, line: 1, col: 0, text: "" };
+			  const syntaxError = (message) => {
+			    const referenceToken = previous || defaultErrorToken;
+			    const errorToken = {
+			      ...referenceToken,
+			      offset: referenceToken.offset + referenceToken.text.length,
+			      col: referenceToken.col + referenceToken.text.length
+			    };
+			    throw new SyntaxError(lexer.formatError(errorToken, message));
+			  };
+
+			  return { next, peek, syntaxError };
+			};
+
+			const JsonPointer$2 = lib$4;
+			const jsonLexer = lexer;
+
+
+			const defaultReviver = (key, value) => value;
+			const parse$3 = (json, reviver = defaultReviver) => {
+			  const lexer = jsonLexer(json);
+			  const value =  parseValue(lexer, "", JsonPointer$2.nil, reviver);
+
+			  const token = lexer.peek();
+			  if (token) {
+			    lexer.syntaxError("A value has been parsed, but more tokens were found");
+			  }
+			  return value;
+			};
+
+			const parseValue = (lexer, key, pointer, reviver) => {
+			  let value;
+			  const token = lexer.next();
+			  switch (token?.type) {
+			    case "true":
+			    case "false":
+			    case "null":
+			    case "number":
+			    case "string":
+			      value = token.value;
+			      break;
+			    case "{":
+			      value = parseObject(lexer, key, pointer, reviver);
+			      break;
+			    case "[":
+			      value = parseArray(lexer, key, pointer, reviver);
+			      break;
+			    default:
+			      lexer.syntaxError("Expected a JSON value");
+			  }
+
+			  return reviver(key, value, pointer);
+			};
+
+			const parseObject = (lexer, key, pointer, reviver) => {
+			  const value = {};
+
+			  if (lexer.peek()?.type !== "}") {
+			    parseProperties(lexer, key, pointer, reviver, value);
+			  }
+
+			  lexer.next("}");
+
+			  return value;
+			};
+
+			const parseProperties = (lexer, key, pointer, reviver, value) => {
+			  const propertyName = lexer.next("string").value;
+			  lexer.next(":");
+			  if (!isValueToken(lexer.peek())) {
+			    lexer.syntaxError("Expected a JSON value");
+			  }
+			  value[propertyName] = parseValue(lexer, propertyName, JsonPointer$2.append(propertyName, pointer), reviver);
+
+			  if (lexer.peek()?.type === ",") {
+			    lexer.next(); // burn comma
+			    parseProperties(lexer, propertyName, pointer, reviver, value);
+			  } else if (isValueToken(lexer.peek())) {
+			    lexer.next(",");
+			  }
+			};
+
+			const parseArray = (lexer, key, pointer, reviver) => {
+			  const value = [];
+
+			  if (lexer.peek()?.type !== "]") {
+			    parseItems(lexer, 0, pointer, reviver, value);
+			  }
+
+			  lexer.next("]");
+
+			  return value;
+			};
+
+			const parseItems = (lexer, key, pointer, reviver, value) => {
+			  if (!isValueToken(lexer.peek())) {
+			    lexer.syntaxError("Expected a JSON value");
+			  }
+			  value[key] = parseValue(lexer, key, JsonPointer$2.append(key, pointer), reviver);
+			  if (lexer.peek()?.type === ",") {
+			    lexer.next(); // burn comma
+			    parseItems(lexer, key + 1, pointer, reviver, value);
+			  } else if (isValueToken(lexer.peek())) {
+			    lexer.next(",");
+			  }
+			};
+
+			const valueType = new Set(["string", "number", "true", "false", "null", "[", "{"]);
+			const isValueToken = (token) => valueType.has(token?.type);
+
+			var parse_1 = parse$3;
+
+			const JsonPointer$1 = lib$4;
+
+
+			const defaultReplacer = (key, value) => value;
+			const stringify$2 = (value, replacer = defaultReplacer, space = "") => {
+			  return stringifyValue(value, replacer, space, "", JsonPointer$1.nil, 1);
+			};
+
+			const stringifyValue = (value, replacer, space, key, pointer, depth) => {
+			  value = replacer(key, value, pointer);
+			  let result;
+			  if (Array.isArray(value)) {
+			    result = stringifyArray(value, replacer, space, pointer, depth);
+			  } else if (typeof value === "object" && value !== null) {
+			    result = stringifyObject(value, replacer, space, pointer, depth);
+			  } else {
+			    result = JSON.stringify(value);
+			  }
+
+			  return result;
+			};
+
+			const stringifyArray = (value, replacer, space, pointer, depth) => {
+			  if (value.length === 0) {
+			    space = "";
+			  }
+			  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
+			  return "[" + padding + space + value
+			    .map((item, index) => {
+			      const indexPointer = JsonPointer$1.append(index, pointer);
+			      return stringifyValue(item, replacer, space, index, indexPointer, depth + 1);
+			    })
+			    .join(`,${padding}${space}`) + padding + "]";
+			};
+
+			const stringifyObject = (value, replacer, space, pointer, depth) => {
+			  if (Object.keys(value).length === 0) {
+			    space = "";
+			  }
+			  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
+			  const spacing = space ? " " : "";
+			  return "{" + padding + space + Object.entries(value)
+			    .map(([key, value]) => {
+			      const keyPointer = JsonPointer$1.append(key, pointer);
+			      return JSON.stringify(key) + ":" + spacing + stringifyValue(value, replacer, space, key, keyPointer, depth + 1);
+			    })
+			    .join(`,${padding}${space}`) + padding + "}";
+			};
+
+			var stringify_1 = stringify$2;
+
+			const parse$2 = parse_1;
+			const stringify$1 = stringify_1;
+
+
+			var lib$2 = { parse: parse$2, stringify: stringify$1 };
+
 			var fetch_browser = fetch;
 
 			var contentType = {};
@@ -2491,8 +3374,9 @@ System.register('JsonSchema', [], (function (exports) {
 			var mediaTypes = { addPlugin, parse, getContentType };
 
 			const curry$1 = justCurryIt$1;
-			const Pact$a = lib$2;
-			const JsonPointer = lib$3;
+			const Pact$a = lib$3;
+			const Json = lib$2;
+			const JsonPointer = lib$4;
 			const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 			const fetch$1 = fetch_browser;
 			const Reference$1 = reference;
@@ -2774,36 +3658,43 @@ System.register('JsonSchema', [], (function (exports) {
 			const toSchema = (schemaDoc, options = {}) => {
 			  const fullOptions = { ...toSchemaDefaultOptions, ...options };
 
-			  const schema = JSON.parse(JSON.stringify(schemaDoc.schema, (key, value) => {
-			    if (!Reference$1.isReference(value)) {
-			      return value;
+			  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
+			  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
+
+			  const anchors = {};
+			  for (const anchor in schemaDoc.anchors) {
+			    if (anchor !== "" && !schemaDoc.dynamicAnchors[anchor]) {
+			      anchors[schemaDoc.anchors[anchor]] = anchor;
 			    }
+			  }
 
-			    const refValue = Reference$1.value(value);
-			    const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
-			    const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
-			    if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
-			      return;
+			  const dynamicAnchors = {};
+			  for (const anchor in schemaDoc.dynamicAnchors) {
+			    const pointer = urlFragment(schemaDoc.dynamicAnchors[anchor]);
+			    dynamicAnchors[pointer] = anchor;
+			  }
+
+			  const schema = JSON.parse(Json.stringify(schemaDoc.schema, (key, value, pointer) => {
+			    if (Reference$1.isReference(value)) {
+			      const refValue = Reference$1.value(value);
+			      const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
+			      const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
+			      if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
+			        return;
+			      } else {
+			        return Reference$1.value(value);
+			      }
 			    } else {
-			      return Reference$1.value(value);
+			      if (pointer in anchors) {
+			        value = { [anchorToken]: anchors[pointer], ...value };
+			      }
+			      if (pointer in dynamicAnchors) {
+			        value = { [dynamicAnchorToken]: dynamicAnchors[pointer], ...value };
+			      }
+			      return value;
 			    }
 			  }));
 
-			  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
-			  Object.entries(schemaDoc.dynamicAnchors)
-			    .forEach(([anchor, uri]) => {
-			      const pointer = JsonPointer.append(dynamicAnchorToken, urlFragment(uri));
-			      JsonPointer.assign(pointer, schema, anchor);
-			    });
-
-			  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
-			  Object.entries(schemaDoc.anchors)
-			    .filter(([anchor]) => anchor !== "" && !(anchor in schemaDoc.dynamicAnchors))
-			    .forEach(([anchor, pointer]) => {
-			      const anchorPointer = JsonPointer.append(anchorToken, pointer);
-			      JsonPointer.assign(anchorPointer, schema, anchor);
-			    });
-
 			  const baseToken = getConfig(schemaDoc.dialectId, "baseToken");
 			  const id = relativeUri(fullOptions.parentId, schemaDoc.id);
 			  const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
@@ -3054,7 +3945,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  addMediaTypePlugin: MediaTypes.addPlugin
 			};
 
-			const Pact$9 = lib$2;
+			const Pact$9 = lib$3;
 			const PubSub = pubsub.exports;
 			const Core$x = core$2;
 			const Instance$B = instance;
@@ -3285,7 +4176,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var additionalProperties6 = { compile: compile$G, interpret: interpret$G, collectEvaluatedProperties: collectEvaluatedProperties$c };
 
 			const { Core: Core$r, Schema: Schema$H } = lib$1;
-			const Pact$8 = lib$2;
+			const Pact$8 = lib$3;
 
 
 			const compile$F = (schema, ast) => Pact$8.pipeline([
@@ -3314,7 +4205,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var allOf = { compile: compile$F, interpret: interpret$F, collectEvaluatedProperties: collectEvaluatedProperties$b, collectEvaluatedItems: collectEvaluatedItems$c };
 
 			const { Core: Core$q, Schema: Schema$G } = lib$1;
-			const Pact$7 = lib$2;
+			const Pact$7 = lib$3;
 
 
 			const compile$E = (schema, ast) => Pact$7.pipeline([
@@ -3457,7 +4348,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var containsMinContainsMaxContains = { compile: compile$B, interpret: interpret$B, collectEvaluatedItems: collectEvaluatedItems$a };
 
 			const { Core: Core$n, Schema: Schema$D } = lib$1;
-			const Pact$6 = lib$2;
+			const Pact$6 = lib$3;
 
 
 			const compile$A = async (schema, ast) => {
@@ -3473,7 +4364,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var definitions = { compile: compile$A, interpret: interpret$A };
 
 			const { Core: Core$m, Schema: Schema$C, Instance: Instance$s } = lib$1;
-			const Pact$5 = lib$2;
+			const Pact$5 = lib$3;
 
 
 			const compile$z = (schema, ast) => Pact$5.pipeline([
@@ -3503,7 +4394,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var dependencies = { compile: compile$z, interpret: interpret$z };
 
 			const { Schema: Schema$B, Instance: Instance$r } = lib$1;
-			const Pact$4 = lib$2;
+			const Pact$4 = lib$3;
 
 
 			const compile$y = (schema) => Pact$4.pipeline([
@@ -3523,7 +4414,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var dependentRequired = { compile: compile$y, interpret: interpret$y };
 
 			const { Core: Core$l, Schema: Schema$A, Instance: Instance$q } = lib$1;
-			const Pact$3 = lib$2;
+			const Pact$3 = lib$3;
 
 
 			const compile$x = (schema, ast) => Pact$3.pipeline([
@@ -3932,7 +4823,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var pattern = { compile: compile$b, interpret: interpret$b };
 
 			const { Core: Core$d, Schema: Schema$f, Instance: Instance$8 } = lib$1;
-			const Pact$2 = lib$2;
+			const Pact$2 = lib$3;
 
 
 			const compile$a = (schema, ast) => Pact$2.pipeline([
@@ -3970,7 +4861,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var common = { isObject, escapeRegExp: escapeRegExp$1, splitUrl: splitUrl$1 };
 
 			const { Core: Core$c, Schema: Schema$e, Instance: Instance$7 } = lib$1;
-			const Pact$1 = lib$2;
+			const Pact$1 = lib$3;
 			const { escapeRegExp } = common;
 
 
@@ -4058,7 +4949,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var required = { compile: compile$5, interpret: interpret$5 };
 
 			const { Core: Core$8, Schema: Schema$a, Instance: Instance$4 } = lib$1;
-			const Pact = lib$2;
+			const Pact = lib$3;
 
 
 			const compile$4 = (schema, ast) => {