@inventreedb/ui 0.0.2 → 0.0.3

package/dist/node_modules/@messageformat/parser/lib/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sources":["../../../../../node_modules/@messageformat/parser/lib/parser.js"],"sourcesContent":["\"use strict\";\n/**\n * An AST parser for ICU MessageFormat strings\n *\n * @packageDocumentation\n * @example\n * ```\n * import { parse } from '@messageformat/parser\n *\n * parse('So {wow}.')\n * [ { type: 'content', value: 'So ' },\n *   { type: 'argument', arg: 'wow' },\n *   { type: 'content', value: '.' } ]\n *\n *\n * parse('Such { thing }. { count, selectordinal, one {First} two {Second}' +\n *       '                  few {Third} other {#th} } word.')\n * [ { type: 'content', value: 'Such ' },\n *   { type: 'argument', arg: 'thing' },\n *   { type: 'content', value: '. ' },\n *   { type: 'selectordinal',\n *     arg: 'count',\n *     cases: [\n *       { key: 'one', tokens: [ { type: 'content', value: 'First' } ] },\n *       { key: 'two', tokens: [ { type: 'content', value: 'Second' } ] },\n *       { key: 'few', tokens: [ { type: 'content', value: 'Third' } ] },\n *       { key: 'other',\n *         tokens: [ { type: 'octothorpe' }, { type: 'content', value: 'th' } ] }\n *     ] },\n *   { type: 'content', value: ' word.' } ]\n *\n *\n * parse('Many{type,select,plural{ numbers}selectordinal{ counting}' +\n *                          'select{ choices}other{ some {type}}}.')\n * [ { type: 'content', value: 'Many' },\n *   { type: 'select',\n *     arg: 'type',\n *     cases: [\n *       { key: 'plural', tokens: [ { type: 'content', value: 'numbers' } ] },\n *       { key: 'selectordinal', tokens: [ { type: 'content', value: 'counting' } ] },\n *       { key: 'select', tokens: [ { type: 'content', value: 'choices' } ] },\n *       { key: 'other',\n *         tokens: [ { type: 'content', value: 'some ' }, { type: 'argument', arg: 'type' } ] }\n *     ] },\n *   { type: 'content', value: '.' } ]\n *\n *\n * parse('{Such compliance')\n * // ParseError: invalid syntax at line 1 col 7:\n * //\n * //  {Such compliance\n * //        ^\n *\n *\n * const msg = '{words, plural, zero{No words} one{One word} other{# words}}'\n * parse(msg)\n * [ { type: 'plural',\n *     arg: 'words',\n *     cases: [\n *       { key: 'zero', tokens: [ { type: 'content', value: 'No words' } ] },\n *       { key: 'one', tokens: [ { type: 'content', value: 'One word' } ] },\n *       { key: 'other',\n *         tokens: [ { type: 'octothorpe' }, { type: 'content', value: ' words' } ] }\n *     ] } ]\n *\n *\n * parse(msg, { cardinal: [ 'one', 'other' ], ordinal: [ 'one', 'two', 'few', 'other' ] })\n * // ParseError: The plural case zero is not valid in this locale at line 1 col 17:\n * //\n * //   {words, plural, zero{\n * //                   ^\n * ```\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parse = exports.ParseError = void 0;\nconst lexer_js_1 = require(\"./lexer.js\");\nconst getContext = (lt) => ({\n    offset: lt.offset,\n    line: lt.line,\n    col: lt.col,\n    text: lt.text,\n    lineBreaks: lt.lineBreaks\n});\nconst isSelectType = (type) => type === 'plural' || type === 'select' || type === 'selectordinal';\nfunction strictArgStyleParam(lt, param) {\n    let value = '';\n    let text = '';\n    for (const p of param) {\n        const pText = p.ctx.text;\n        text += pText;\n        switch (p.type) {\n            case 'content':\n                value += p.value;\n                break;\n            case 'argument':\n            case 'function':\n            case 'octothorpe':\n                value += pText;\n                break;\n            default:\n                throw new ParseError(lt, `Unsupported part in strict mode function arg style: ${pText}`);\n        }\n    }\n    const c = {\n        type: 'content',\n        value: value.trim(),\n        ctx: Object.assign({}, param[0].ctx, { text })\n    };\n    return [c];\n}\nconst strictArgTypes = [\n    'number',\n    'date',\n    'time',\n    'spellout',\n    'ordinal',\n    'duration'\n];\nconst defaultPluralKeys = ['zero', 'one', 'two', 'few', 'many', 'other'];\n/**\n * Thrown by {@link parse} on error\n *\n * @public\n */\nclass ParseError extends Error {\n    /** @internal */\n    constructor(lt, msg) {\n        super(lexer_js_1.lexer.formatError(lt, msg));\n    }\n}\nexports.ParseError = ParseError;\nclass Parser {\n    constructor(src, opt) {\n        var _a, _b, _c, _d;\n        this.lexer = lexer_js_1.lexer.reset(src);\n        this.cardinalKeys = (_a = opt === null || opt === void 0 ? void 0 : opt.cardinal) !== null && _a !== void 0 ? _a : defaultPluralKeys;\n        this.ordinalKeys = (_b = opt === null || opt === void 0 ? void 0 : opt.ordinal) !== null && _b !== void 0 ? _b : defaultPluralKeys;\n        this.strict = (_c = opt === null || opt === void 0 ? void 0 : opt.strict) !== null && _c !== void 0 ? _c : false;\n        this.strictPluralKeys = (_d = opt === null || opt === void 0 ? void 0 : opt.strictPluralKeys) !== null && _d !== void 0 ? _d : true;\n    }\n    parse() {\n        return this.parseBody(false, true);\n    }\n    checkSelectKey(lt, type, key) {\n        if (key[0] === '=') {\n            if (type === 'select')\n                throw new ParseError(lt, `The case ${key} is not valid with select`);\n        }\n        else if (type !== 'select') {\n            const keys = type === 'plural' ? this.cardinalKeys : this.ordinalKeys;\n            if (this.strictPluralKeys && keys.length > 0 && !keys.includes(key)) {\n                const msg = `The ${type} case ${key} is not valid in this locale`;\n                throw new ParseError(lt, msg);\n            }\n        }\n    }\n    parseSelect({ value: arg }, inPlural, ctx, type) {\n        const sel = { type, arg, cases: [], ctx };\n        if (type === 'plural' || type === 'selectordinal')\n            inPlural = true;\n        else if (this.strict)\n            inPlural = false;\n        for (const lt of this.lexer) {\n            switch (lt.type) {\n                case 'offset':\n                    if (type === 'select')\n                        throw new ParseError(lt, 'Unexpected plural offset for select');\n                    if (sel.cases.length > 0)\n                        throw new ParseError(lt, 'Plural offset must be set before cases');\n                    sel.pluralOffset = Number(lt.value);\n                    ctx.text += lt.text;\n                    ctx.lineBreaks += lt.lineBreaks;\n                    break;\n                case 'case': {\n                    this.checkSelectKey(lt, type, lt.value);\n                    sel.cases.push({\n                        key: lt.value,\n                        tokens: this.parseBody(inPlural),\n                        ctx: getContext(lt)\n                    });\n                    break;\n                }\n                case 'end':\n                    return sel;\n                /* istanbul ignore next: never happens */\n                default:\n                    throw new ParseError(lt, `Unexpected lexer token: ${lt.type}`);\n            }\n        }\n        throw new ParseError(null, 'Unexpected message end');\n    }\n    parseArgToken(lt, inPlural) {\n        const ctx = getContext(lt);\n        const argType = this.lexer.next();\n        if (!argType)\n            throw new ParseError(null, 'Unexpected message end');\n        ctx.text += argType.text;\n        ctx.lineBreaks += argType.lineBreaks;\n        if (this.strict &&\n            (argType.type === 'func-simple' || argType.type === 'func-args') &&\n            !strictArgTypes.includes(argType.value)) {\n            const msg = `Invalid strict mode function arg type: ${argType.value}`;\n            throw new ParseError(lt, msg);\n        }\n        switch (argType.type) {\n            case 'end':\n                return { type: 'argument', arg: lt.value, ctx };\n            case 'func-simple': {\n                const end = this.lexer.next();\n                if (!end)\n                    throw new ParseError(null, 'Unexpected message end');\n                /* istanbul ignore if: never happens */\n                if (end.type !== 'end')\n                    throw new ParseError(end, `Unexpected lexer token: ${end.type}`);\n                ctx.text += end.text;\n                if (isSelectType(argType.value.toLowerCase()))\n                    throw new ParseError(argType, `Invalid type identifier: ${argType.value}`);\n                return {\n                    type: 'function',\n                    arg: lt.value,\n                    key: argType.value,\n                    ctx\n                };\n            }\n            case 'func-args': {\n                if (isSelectType(argType.value.toLowerCase())) {\n                    const msg = `Invalid type identifier: ${argType.value}`;\n                    throw new ParseError(argType, msg);\n                }\n                let param = this.parseBody(this.strict ? false : inPlural);\n                if (this.strict && param.length > 0)\n                    param = strictArgStyleParam(lt, param);\n                return {\n                    type: 'function',\n                    arg: lt.value,\n                    key: argType.value,\n                    param,\n                    ctx\n                };\n            }\n            case 'select':\n                /* istanbul ignore else: never happens */\n                if (isSelectType(argType.value))\n                    return this.parseSelect(lt, inPlural, ctx, argType.value);\n                else\n                    throw new ParseError(argType, `Unexpected select type ${argType.value}`);\n            /* istanbul ignore next: never happens */\n            default:\n                throw new ParseError(argType, `Unexpected lexer token: ${argType.type}`);\n        }\n    }\n    parseBody(inPlural, atRoot) {\n        const tokens = [];\n        let content = null;\n        for (const lt of this.lexer) {\n            if (lt.type === 'argument') {\n                if (content)\n                    content = null;\n                tokens.push(this.parseArgToken(lt, inPlural));\n            }\n            else if (lt.type === 'octothorpe' && inPlural) {\n                if (content)\n                    content = null;\n                tokens.push({ type: 'octothorpe', ctx: getContext(lt) });\n            }\n            else if (lt.type === 'end' && !atRoot) {\n                return tokens;\n            }\n            else {\n                let value = lt.value;\n                if (!inPlural && lt.type === 'quoted' && value[0] === '#') {\n                    if (value.includes('{')) {\n                        const errMsg = `Unsupported escape pattern: ${value}`;\n                        throw new ParseError(lt, errMsg);\n                    }\n                    value = lt.text;\n                }\n                if (content) {\n                    content.value += value;\n                    content.ctx.text += lt.text;\n                    content.ctx.lineBreaks += lt.lineBreaks;\n                }\n                else {\n                    content = { type: 'content', value, ctx: getContext(lt) };\n                    tokens.push(content);\n                }\n            }\n        }\n        if (atRoot)\n            return tokens;\n        throw new ParseError(null, 'Unexpected message end');\n    }\n}\n/**\n * Parse an input string into an array of tokens\n *\n * @public\n * @remarks\n * The parser only supports the default `DOUBLE_OPTIONAL`\n * {@link http://www.icu-project.org/apiref/icu4c/messagepattern_8h.html#af6e0757e0eb81c980b01ee5d68a9978b | apostrophe mode}.\n */\nfunction parse(src, options = {}) {\n    const parser = new Parser(src, options);\n    return parser.parse();\n}\nexports.parse = parse;\n"],"names":["require$$0","parser"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/moo/moo.js

@@ -0,0 +1,539 @@
+import { __module as moo$1 } from "../../_virtual/moo.js";
+var moo = moo$1.exports;
+var hasRequiredMoo;
+function requireMoo() {
+  if (hasRequiredMoo) return moo$1.exports;
+  hasRequiredMoo = 1;
+  (function(module) {
+    (function(root, factory) {
+      if (module.exports) {
+        module.exports = factory();
+      } else {
+        root.moo = factory();
+      }
+    })(moo, 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)) {
+          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");
+        }
+        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
+        };
+        for (var key in obj) {
+          if (hasOwnProperty.call(obj, key)) {
+            options[key] = obj[key];
+          }
+        }
+        if (typeof options.type === "string" && type !== options.type) {
+          throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')");
+        }
+        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 = /* @__PURE__ */ Object.create(null);
+        var fastAllowed = true;
+        var unicodeFlag = null;
+        var groups = [];
+        var parts = [];
+        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) {
+            throw new Error("Inheritance is not allowed in stateless lexers");
+          }
+          if (options.error || options.fallback) {
+            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;
+            }
+          }
+          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 + "')");
+            }
+          }
+          if (match.length === 0) {
+            continue;
+          }
+          fastAllowed = false;
+          groups.push(options);
+          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");
+            }
+          }
+          var pat = reUnion(match.map(regexpOrLiteral));
+          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");
+          }
+          if (!options.lineBreaks && regexp.test("\n")) {
+            throw new Error("Rule should declare lineBreaks: " + regexp);
+          }
+          parts.push(reCapture(pat));
+        }
+        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, 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) {
+        var isMap = typeof Map !== "undefined";
+        var reverseMap = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ 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) {
+        return re.exec(buffer);
+      } : function(re, buffer) {
+        var match = re.exec(buffer);
+        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] !== void 0) {
+            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 (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;
+        }
+        var group = this.fast[buffer.charCodeAt(index)];
+        if (group) {
+          return this._token(group, buffer.charAt(index), index);
+        }
+        var re = this.re;
+        re.lastIndex = index;
+        var match = eat(re, 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;
+          return this._token(error, buffer.slice(index, match.index), index);
+        }
+        return this._token(group, text, index);
+      };
+      Lexer.prototype._token = function(group, text, offset) {
+        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,
+          toString: tokenToString,
+          offset,
+          lineBreaks,
+          line: this.line,
+          col: this.col
+        };
+        var size = text.length;
+        this.index += size;
+        this.line += lineBreaks;
+        if (lineBreaks !== 0) {
+          this.col = size - nl + 1;
+        } else {
+          this.col += size;
+        }
+        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) {
+          var text = this.buffer.slice(this.index);
+          var token = {
+            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,
+        states: compileStates,
+        error: Object.freeze({ error: true }),
+        fallback: Object.freeze({ fallback: true }),
+        keywords: keywordTransform
+      };
+    });
+  })(moo$1);
+  return moo$1.exports;
+}
+export {
+  requireMoo as __require
+};
+//# sourceMappingURL=moo.js.map

package/dist/node_modules/moo/moo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moo.js","sources":["../../../node_modules/moo/moo.js"],"sourcesContent":["(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([], factory) /* global define */\n  } else if (typeof module === 'object' && module.exports) {\n    module.exports = factory()\n  } else {\n    root.moo = factory()\n  }\n}(this, function() {\n  'use strict';\n\n  var hasOwnProperty = Object.prototype.hasOwnProperty\n  var toString = Object.prototype.toString\n  var hasSticky = typeof new RegExp().sticky === 'boolean'\n\n  /***************************************************************************/\n\n  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }\n  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }\n\n  function reEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')\n  }\n  function reGroups(s) {\n    var re = new RegExp('|' + s)\n    return re.exec('').length - 1\n  }\n  function reCapture(s) {\n    return '(' + s + ')'\n  }\n  function reUnion(regexps) {\n    if (!regexps.length) return '(?!)'\n    var source =  regexps.map(function(s) {\n      return \"(?:\" + s + \")\"\n    }).join('|')\n    return \"(?:\" + source + \")\"\n  }\n\n  function regexpOrLiteral(obj) {\n    if (typeof obj === 'string') {\n      return '(?:' + reEscape(obj) + ')'\n\n    } else if (isRegExp(obj)) {\n      // TODO: consider /u support\n      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')\n      if (obj.global) throw new Error('RegExp /g flag is implied')\n      if (obj.sticky) throw new Error('RegExp /y flag is implied')\n      if (obj.multiline) throw new Error('RegExp /m flag is implied')\n      return obj.source\n\n    } else {\n      throw new Error('Not a pattern: ' + obj)\n    }\n  }\n\n  function pad(s, length) {\n    if (s.length > length) {\n      return s\n    }\n    return Array(length - s.length + 1).join(\" \") + s\n  }\n\n  function lastNLines(string, numLines) {\n    var position = string.length\n    var lineBreaks = 0;\n    while (true) {\n      var idx = string.lastIndexOf(\"\\n\", position - 1)\n      if (idx === -1) {\n        break;\n      } else {\n        lineBreaks++\n      }\n      position = idx\n      if (lineBreaks === numLines) {\n        break;\n      }\n      if (position === 0) {\n        break;\n      }\n    }\n    var startPosition = \n      lineBreaks < numLines ?\n      0 : \n      position + 1\n    return string.substring(startPosition).split(\"\\n\")\n  }\n\n  function objectToRules(object) {\n    var keys = Object.getOwnPropertyNames(object)\n    var result = []\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      var thing = object[key]\n      var rules = [].concat(thing)\n      if (key === 'include') {\n        for (var j = 0; j < rules.length; j++) {\n          result.push({include: rules[j]})\n        }\n        continue\n      }\n      var match = []\n      rules.forEach(function(rule) {\n        if (isObject(rule)) {\n          if (match.length) result.push(ruleOptions(key, match))\n          result.push(ruleOptions(key, rule))\n          match = []\n        } else {\n          match.push(rule)\n        }\n      })\n      if (match.length) result.push(ruleOptions(key, match))\n    }\n    return result\n  }\n\n  function arrayToRules(array) {\n    var result = []\n    for (var i = 0; i < array.length; i++) {\n      var obj = array[i]\n      if (obj.include) {\n        var include = [].concat(obj.include)\n        for (var j = 0; j < include.length; j++) {\n          result.push({include: include[j]})\n        }\n        continue\n      }\n      if (!obj.type) {\n        throw new Error('Rule has no type: ' + JSON.stringify(obj))\n      }\n      result.push(ruleOptions(obj.type, obj))\n    }\n    return result\n  }\n\n  function ruleOptions(type, obj) {\n    if (!isObject(obj)) {\n      obj = { match: obj }\n    }\n    if (obj.include) {\n      throw new Error('Matching rules cannot also include states')\n    }\n\n    // nb. error and fallback imply lineBreaks\n    var options = {\n      defaultType: type,\n      lineBreaks: !!obj.error || !!obj.fallback,\n      pop: false,\n      next: null,\n      push: null,\n      error: false,\n      fallback: false,\n      value: null,\n      type: null,\n      shouldThrow: false,\n    }\n\n    // Avoid Object.assign(), so we support IE9+\n    for (var key in obj) {\n      if (hasOwnProperty.call(obj, key)) {\n        options[key] = obj[key]\n      }\n    }\n\n    // type transform cannot be a string\n    if (typeof options.type === 'string' && type !== options.type) {\n      throw new Error(\"Type transform cannot be a string (type '\" + options.type + \"' for token '\" + type + \"')\")\n    }\n\n    // convert to array\n    var match = options.match\n    options.match = Array.isArray(match) ? match : match ? [match] : []\n    options.match.sort(function(a, b) {\n      return isRegExp(a) && isRegExp(b) ? 0\n           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length\n    })\n    return options\n  }\n\n  function toRules(spec) {\n    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)\n  }\n\n  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true})\n  function compileRules(rules, hasStates) {\n    var errorRule = null\n    var fast = Object.create(null)\n    var fastAllowed = true\n    var unicodeFlag = null\n    var groups = []\n    var parts = []\n\n    // If there is a fallback rule, then disable fast matching\n    for (var i = 0; i < rules.length; i++) {\n      if (rules[i].fallback) {\n        fastAllowed = false\n      }\n    }\n\n    for (var i = 0; i < rules.length; i++) {\n      var options = rules[i]\n\n      if (options.include) {\n        // all valid inclusions are removed by states() preprocessor\n        throw new Error('Inheritance is not allowed in stateless lexers')\n      }\n\n      if (options.error || options.fallback) {\n        // errorRule can only be set once\n        if (errorRule) {\n          if (!options.fallback === !errorRule.fallback) {\n            throw new Error(\"Multiple \" + (options.fallback ? \"fallback\" : \"error\") + \" rules not allowed (for token '\" + options.defaultType + \"')\")\n          } else {\n            throw new Error(\"fallback and error are mutually exclusive (for token '\" + options.defaultType + \"')\")\n          }\n        }\n        errorRule = options\n      }\n\n      var match = options.match.slice()\n      if (fastAllowed) {\n        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {\n          var word = match.shift()\n          fast[word.charCodeAt(0)] = options\n        }\n      }\n\n      // Warn about inappropriate state-switching options\n      if (options.pop || options.push || options.next) {\n        if (!hasStates) {\n          throw new Error(\"State-switching options are not allowed in stateless lexers (for token '\" + options.defaultType + \"')\")\n        }\n        if (options.fallback) {\n          throw new Error(\"State-switching options are not allowed on fallback tokens (for token '\" + options.defaultType + \"')\")\n        }\n      }\n\n      // Only rules with a .match are included in the RegExp\n      if (match.length === 0) {\n        continue\n      }\n      fastAllowed = false\n\n      groups.push(options)\n\n      // Check unicode flag is used everywhere or nowhere\n      for (var j = 0; j < match.length; j++) {\n        var obj = match[j]\n        if (!isRegExp(obj)) {\n          continue\n        }\n\n        if (unicodeFlag === null) {\n          unicodeFlag = obj.unicode\n        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {\n          throw new Error('If one rule is /u then all must be')\n        }\n      }\n\n      // convert to RegExp\n      var pat = reUnion(match.map(regexpOrLiteral))\n\n      // validate\n      var regexp = new RegExp(pat)\n      if (regexp.test(\"\")) {\n        throw new Error(\"RegExp matches empty string: \" + regexp)\n      }\n      var groupCount = reGroups(pat)\n      if (groupCount > 0) {\n        throw new Error(\"RegExp has capture groups: \" + regexp + \"\\nUse (?: … ) instead\")\n      }\n\n      // try and detect rules matching newlines\n      if (!options.lineBreaks && regexp.test('\\n')) {\n        throw new Error('Rule should declare lineBreaks: ' + regexp)\n      }\n\n      // store regex\n      parts.push(reCapture(pat))\n    }\n\n\n    // If there's no fallback rule, use the sticky flag so we only look for\n    // matches at the current index.\n    //\n    // If we don't support the sticky flag, then fake it using an irrefutable\n    // match (i.e. an empty pattern).\n    var fallbackRule = errorRule && errorRule.fallback\n    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm'\n    var suffix = hasSticky || fallbackRule ? '' : '|'\n\n    if (unicodeFlag === true) flags += \"u\"\n    var combined = new RegExp(reUnion(parts) + suffix, flags)\n    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}\n  }\n\n  function compile(rules) {\n    var result = compileRules(toRules(rules))\n    return new Lexer({start: result}, 'start')\n  }\n\n  function checkStateGroup(g, name, map) {\n    var state = g && (g.push || g.next)\n    if (state && !map[state]) {\n      throw new Error(\"Missing state '\" + state + \"' (in token '\" + g.defaultType + \"' of state '\" + name + \"')\")\n    }\n    if (g && g.pop && +g.pop !== 1) {\n      throw new Error(\"pop must be 1 (in token '\" + g.defaultType + \"' of state '\" + name + \"')\")\n    }\n  }\n  function compileStates(states, start) {\n    var all = states.$all ? toRules(states.$all) : []\n    delete states.$all\n\n    var keys = Object.getOwnPropertyNames(states)\n    if (!start) start = keys[0]\n\n    var ruleMap = Object.create(null)\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      ruleMap[key] = toRules(states[key]).concat(all)\n    }\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      var rules = ruleMap[key]\n      var included = Object.create(null)\n      for (var j = 0; j < rules.length; j++) {\n        var rule = rules[j]\n        if (!rule.include) continue\n        var splice = [j, 1]\n        if (rule.include !== key && !included[rule.include]) {\n          included[rule.include] = true\n          var newRules = ruleMap[rule.include]\n          if (!newRules) {\n            throw new Error(\"Cannot include nonexistent state '\" + rule.include + \"' (in state '\" + key + \"')\")\n          }\n          for (var k = 0; k < newRules.length; k++) {\n            var newRule = newRules[k]\n            if (rules.indexOf(newRule) !== -1) continue\n            splice.push(newRule)\n          }\n        }\n        rules.splice.apply(rules, splice)\n        j--\n      }\n    }\n\n    var map = Object.create(null)\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      map[key] = compileRules(ruleMap[key], true)\n    }\n\n    for (var i = 0; i < keys.length; i++) {\n      var name = keys[i]\n      var state = map[name]\n      var groups = state.groups\n      for (var j = 0; j < groups.length; j++) {\n        checkStateGroup(groups[j], name, map)\n      }\n      var fastKeys = Object.getOwnPropertyNames(state.fast)\n      for (var j = 0; j < fastKeys.length; j++) {\n        checkStateGroup(state.fast[fastKeys[j]], name, map)\n      }\n    }\n\n    return new Lexer(map, start)\n  }\n\n  function keywordTransform(map) {\n\n    // Use a JavaScript Map to map keywords to their corresponding token type\n    // unless Map is unsupported, then fall back to using an Object:\n    var isMap = typeof Map !== 'undefined'\n    var reverseMap = isMap ? new Map : Object.create(null)\n\n    var types = Object.getOwnPropertyNames(map)\n    for (var i = 0; i < types.length; i++) {\n      var tokenType = types[i]\n      var item = map[tokenType]\n      var keywordList = Array.isArray(item) ? item : [item]\n      keywordList.forEach(function(keyword) {\n        if (typeof keyword !== 'string') {\n          throw new Error(\"keyword must be string (in keyword '\" + tokenType + \"')\")\n        }\n        if (isMap) {\n          reverseMap.set(keyword, tokenType)\n        } else {\n          reverseMap[keyword] = tokenType\n        }\n      })\n    }\n    return function(k) {\n      return isMap ? reverseMap.get(k) : reverseMap[k]\n    }\n  }\n\n  /***************************************************************************/\n\n  var Lexer = function(states, state) {\n    this.startState = state\n    this.states = states\n    this.buffer = ''\n    this.stack = []\n    this.reset()\n  }\n\n  Lexer.prototype.reset = function(data, info) {\n    this.buffer = data || ''\n    this.index = 0\n    this.line = info ? info.line : 1\n    this.col = info ? info.col : 1\n    this.queuedToken = info ? info.queuedToken : null\n    this.queuedText = info ? info.queuedText: \"\";\n    this.queuedThrow = info ? info.queuedThrow : null\n    this.setState(info ? info.state : this.startState)\n    this.stack = info && info.stack ? info.stack.slice() : []\n    return this\n  }\n\n  Lexer.prototype.save = function() {\n    return {\n      line: this.line,\n      col: this.col,\n      state: this.state,\n      stack: this.stack.slice(),\n      queuedToken: this.queuedToken,\n      queuedText: this.queuedText,\n      queuedThrow: this.queuedThrow,\n    }\n  }\n\n  Lexer.prototype.setState = function(state) {\n    if (!state || this.state === state) return\n    this.state = state\n    var info = this.states[state]\n    this.groups = info.groups\n    this.error = info.error\n    this.re = info.regexp\n    this.fast = info.fast\n  }\n\n  Lexer.prototype.popState = function() {\n    this.setState(this.stack.pop())\n  }\n\n  Lexer.prototype.pushState = function(state) {\n    this.stack.push(this.state)\n    this.setState(state)\n  }\n\n  var eat = hasSticky ? function(re, buffer) { // assume re is /y\n    return re.exec(buffer)\n  } : function(re, buffer) { // assume re is /g\n    var match = re.exec(buffer)\n    // will always match, since we used the |(?:) trick\n    if (match[0].length === 0) {\n      return null\n    }\n    return match\n  }\n\n  Lexer.prototype._getGroup = function(match) {\n    var groupCount = this.groups.length\n    for (var i = 0; i < groupCount; i++) {\n      if (match[i + 1] !== undefined) {\n        return this.groups[i]\n      }\n    }\n    throw new Error('Cannot find token type for matched text')\n  }\n\n  function tokenToString() {\n    return this.value\n  }\n\n  Lexer.prototype.next = function() {\n    var index = this.index\n\n    // If a fallback token matched, we don't need to re-run the RegExp\n    if (this.queuedGroup) {\n      var token = this._token(this.queuedGroup, this.queuedText, index)\n      this.queuedGroup = null\n      this.queuedText = \"\"\n      return token\n    }\n\n    var buffer = this.buffer\n    if (index === buffer.length) {\n      return // EOF\n    }\n\n    // Fast matching for single characters\n    var group = this.fast[buffer.charCodeAt(index)]\n    if (group) {\n      return this._token(group, buffer.charAt(index), index)\n    }\n\n    // Execute RegExp\n    var re = this.re\n    re.lastIndex = index\n    var match = eat(re, buffer)\n\n    // Error tokens match the remaining buffer\n    var error = this.error\n    if (match == null) {\n      return this._token(error, buffer.slice(index, buffer.length), index)\n    }\n\n    var group = this._getGroup(match)\n    var text = match[0]\n\n    if (error.fallback && match.index !== index) {\n      this.queuedGroup = group\n      this.queuedText = text\n\n      // Fallback tokens contain the unmatched portion of the buffer\n      return this._token(error, buffer.slice(index, match.index), index)\n    }\n\n    return this._token(group, text, index)\n  }\n\n  Lexer.prototype._token = function(group, text, offset) {\n    // count line breaks\n    var lineBreaks = 0\n    if (group.lineBreaks) {\n      var matchNL = /\\n/g\n      var nl = 1\n      if (text === '\\n') {\n        lineBreaks = 1\n      } else {\n        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex }\n      }\n    }\n\n    var token = {\n      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,\n      value: typeof group.value === 'function' ? group.value(text) : text,\n      text: text,\n      toString: tokenToString,\n      offset: offset,\n      lineBreaks: lineBreaks,\n      line: this.line,\n      col: this.col,\n    }\n    // nb. adding more props to token object will make V8 sad!\n\n    var size = text.length\n    this.index += size\n    this.line += lineBreaks\n    if (lineBreaks !== 0) {\n      this.col = size - nl + 1\n    } else {\n      this.col += size\n    }\n\n    // throw, if no rule with {error: true}\n    if (group.shouldThrow) {\n      var err = new Error(this.formatError(token, \"invalid syntax\"))\n      throw err;\n    }\n\n    if (group.pop) this.popState()\n    else if (group.push) this.pushState(group.push)\n    else if (group.next) this.setState(group.next)\n\n    return token\n  }\n\n  if (typeof Symbol !== 'undefined' && Symbol.iterator) {\n    var LexerIterator = function(lexer) {\n      this.lexer = lexer\n    }\n\n    LexerIterator.prototype.next = function() {\n      var token = this.lexer.next()\n      return {value: token, done: !token}\n    }\n\n    LexerIterator.prototype[Symbol.iterator] = function() {\n      return this\n    }\n\n    Lexer.prototype[Symbol.iterator] = function() {\n      return new LexerIterator(this)\n    }\n  }\n\n  Lexer.prototype.formatError = function(token, message) {\n    if (token == null) {\n      // An undefined token indicates EOF\n      var text = this.buffer.slice(this.index)\n      var token = {\n        text: text,\n        offset: this.index,\n        lineBreaks: text.indexOf('\\n') === -1 ? 0 : 1,\n        line: this.line,\n        col: this.col,\n      }\n    }\n    \n    var numLinesAround = 2\n    var firstDisplayedLine = Math.max(token.line - numLinesAround, 1)\n    var lastDisplayedLine = token.line + numLinesAround\n    var lastLineDigits = String(lastDisplayedLine).length\n    var displayedLines = lastNLines(\n        this.buffer, \n        (this.line - token.line) + numLinesAround + 1\n      )\n      .slice(0, 5)\n    var errorLines = []\n    errorLines.push(message + \" at line \" + token.line + \" col \" + token.col + \":\")\n    errorLines.push(\"\")\n    for (var i = 0; i < displayedLines.length; i++) {\n      var line = displayedLines[i]\n      var lineNo = firstDisplayedLine + i\n      errorLines.push(pad(String(lineNo), lastLineDigits) + \"  \" + line);\n      if (lineNo === token.line) {\n        errorLines.push(pad(\"\", lastLineDigits + token.col + 1) + \"^\")\n      }\n    }\n    return errorLines.join(\"\\n\")\n  }\n\n  Lexer.prototype.clone = function() {\n    return new Lexer(this.states, this.state)\n  }\n\n  Lexer.prototype.has = function(tokenType) {\n    return true\n  }\n\n\n  return {\n    compile: compile,\n    states: compileStates,\n    error: Object.freeze({error: true}),\n    fallback: Object.freeze({fallback: true}),\n    keywords: keywordTransform,\n  }\n\n}));\n"],"names":["this"],"mappings":"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","x_google_ignoreList":[0]}