@spyglassmc/mcdoc 0.1.0

package/lib/parser/index.js

@@ -0,0 +1,631 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.type = exports.pathType = exports.unionType = exports.dispatcherType = exports.tupleType = exports.listType = exports.primitiveArrayType = exports.numericType = exports.literalType = exports.stringType = exports.integer = exports.booleanType = exports.anyType = exports.module_ = exports.useStatement = exports.typeAlias = exports.injection = exports.struct = exports.enum_ = exports.typedNumber = exports.float = exports.docComments = exports.docComment = exports.dispatchStatement = exports.attribute = exports.path = exports.identifier = exports.string = exports.resLoc = exports.literal = exports.comment = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const core_1 = require("@spyglassmc/core");
+const locales_1 = require("@spyglassmc/locales");
+/**
+ * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
+ *
+ * `Failure` when there isn't a comment.
+ */
+exports.comment = (0, core_1.validate)(core.comment({
+    singleLinePrefixes: new Set(['//']),
+}), (res, src) => !src.slice(res).startsWith('///'), (0, locales_1.localize)('mcdoc.parser.syntax.doc-comment-unexpected'));
+/**
+ * @returns A parser that parses the gap between **SYNTAX** rules, which may contains whitespace and regular comments.
+ */
+function syntaxGap(
+/* istanbul ignore next */
+delegatesDocComments = false) {
+    return (src, ctx) => {
+        const ans = [];
+        src.skipWhitespace();
+        while (src.canRead() && src.peek(2) === '//' && (!delegatesDocComments || src.peek(3) !== '///')) {
+            const result = (0, exports.comment)(src, ctx);
+            ans.push(result);
+            src.skipWhitespace();
+        }
+        return ans;
+    };
+}
+function syntax(parsers, delegatesDocComments = false) {
+    return (src, ctx) => {
+        src.skipWhitespace();
+        const ans = (0, core_1.sequence)(parsers, syntaxGap(delegatesDocComments))(src, ctx);
+        src.skipWhitespace();
+        return ans;
+    };
+}
+function syntaxRepeat(parser, delegatesDocComments = false) {
+    return (0, core_1.repeat)(parser, syntaxGap(delegatesDocComments));
+}
+function literal(literal, options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'mcdoc:literal',
+            range: core_1.Range.create(src),
+            value: '',
+            colorTokenType: options?.colorTokenType,
+        };
+        ans.value = src.readIf(c => options?.allowedChars?.has(c) ?? (options?.specialChars?.has(c) || /[a-z]/i.test(c)));
+        ans.range.end = src.cursor;
+        if (core_1.Arrayable.toArray(literal).every(l => l !== ans.value)) {
+            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.arrayToMessage)(literal), (0, locales_1.localeQuote)(ans.value)), ans);
+        }
+        return ans;
+    };
+}
+exports.literal = literal;
+function keyword(keyword, options = { colorTokenType: 'keyword' }) {
+    return (src, ctx) => {
+        const result = literal(keyword, options)(src, ctx);
+        if (!core_1.Arrayable.toArray(keyword).includes(result.value)) {
+            return core_1.Failure;
+        }
+        return result;
+    };
+}
+function punctuation(punctuation) {
+    return (src, ctx) => {
+        src.skipWhitespace();
+        if (!src.trySkip(punctuation)) {
+            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.localeQuote)(punctuation), (0, locales_1.localeQuote)(src.peek())), src);
+        }
+        return undefined;
+    };
+}
+function marker(punctuation) {
+    return (src, _ctx) => {
+        src.skipWhitespace();
+        if (!src.trySkip(punctuation)) {
+            return core_1.Failure;
+        }
+        return undefined;
+    };
+}
+function resLoc(options) {
+    return (0, core_1.validate)(core.resourceLocation(options), res => res.namespace !== undefined, (0, locales_1.localize)('mcdoc.parser.resource-location.colon-expected', (0, locales_1.localeQuote)(core_1.ResourceLocation.NamespacePathSep)));
+}
+exports.resLoc = resLoc;
+const UnicodeControlCharacters = Object.freeze([
+    '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06',
+    '\x07', '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D',
+    '\x0E', '\x0F', '\x7F',
+]);
+exports.string = (0, core_1.stopBefore)(core.string({
+    escapable: { characters: ['b', 'f', 'n', 'r', 't', '\\', '"'], unicode: true },
+    quotes: ['"'],
+}), ...UnicodeControlCharacters);
+const identifier = (src, ctx) => {
+    // https://spyglassmc.com/user/mcdoc/#identifier
+    const IdentifierStart = /^[\p{L}\p{Nl}]$/u;
+    const IdentifierContinue = /^[\p{L}\p{Nl}\u200C\u200D\p{Mn}\p{Mc}\p{Nd}\p{Pc}]$/u;
+    const ReservedWords = new Set(['any', 'boolean', 'byte', 'double', 'enum', 'false', 'float', 'int', 'long', 'short', 'string', 'struct', 'super', 'true']);
+    const ans = {
+        type: 'mcdoc:identifier',
+        range: core_1.Range.create(src),
+        options: { category: 'mcdoc' },
+        value: '',
+    };
+    const start = src.innerCursor;
+    if (IdentifierStart.test(src.peek())) {
+        src.skip();
+        while (IdentifierContinue.test(src.peek())) {
+            src.skip();
+        }
+    }
+    else {
+        ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('mcdoc.node.identifier')), src);
+    }
+    ans.value = src.string.slice(start, src.innerCursor);
+    ans.range.end = src.cursor;
+    if (ReservedWords.has(ans.value)) {
+        ctx.err.report((0, locales_1.localize)('mcdoc.parser.identifier.reserved-word', (0, locales_1.localeQuote)(ans.value)), ans);
+    }
+    return ans;
+};
+exports.identifier = identifier;
+function indexBody(options) {
+    const accessorKey = (0, core_1.select)([
+        {
+            prefix: '%',
+            parser: literal(['%key', '%parent'], { specialChars: new Set(['%']) }),
+        },
+        {
+            prefix: '"',
+            parser: exports.string,
+        },
+        {
+            parser: exports.identifier,
+        },
+    ]);
+    const dynamicIndex = (0, core_1.setType)('mcdoc:dynamic_index', syntax([
+        punctuation('['),
+        accessorKey,
+        (0, core_1.repeat)((0, core_1.sequence)([marker('.'), accessorKey])),
+        punctuation(']'),
+    ]));
+    const index = (0, core_1.select)([
+        {
+            prefix: '%',
+            parser: literal(['%fallback', '%none', '%unknown'], { specialChars: new Set(['%']) }),
+        },
+        {
+            prefix: '"',
+            parser: exports.string,
+        },
+        {
+            prefix: '[',
+            parser: dynamicIndex,
+        },
+        {
+            parser: (0, core_1.any)([resLoc({ category: 'mcdoc/dispatcher', accessType: options?.accessType }), exports.identifier]),
+        },
+    ]);
+    return (0, core_1.setType)('mcdoc:index_body', syntax([
+        punctuation('['),
+        index,
+        syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(index)])),
+        (0, core_1.optional)(marker(',')),
+        punctuation(']'),
+    ]));
+}
+const pathSegment = (0, core_1.select)([
+    { prefix: 'super', parser: literal('super') },
+    { parser: exports.identifier },
+]);
+const path = (src, ctx) => {
+    let isAbsolute;
+    if (src.trySkip('::')) {
+        isAbsolute = true;
+    }
+    return (0, core_1.map)((0, core_1.sequence)([
+        pathSegment,
+        (0, core_1.repeat)((0, core_1.sequence)([marker('::'), pathSegment])),
+    ]), res => {
+        const ans = {
+            type: 'mcdoc:path',
+            children: res.children,
+            range: res.range,
+            isAbsolute,
+        };
+        return ans;
+    })(src, ctx);
+};
+exports.path = path;
+const attributeTreePosValues = (0, core_1.setType)('mcdoc:attribute/tree/pos', syntax([
+    { get: () => attributeValue },
+    syntaxRepeat(syntax([marker(','), { get: () => (0, core_1.failOnEmpty)(attributeValue) }], true), true),
+], true));
+const attributeNamedValue = syntax([
+    (0, core_1.select)([
+        { prefix: '"', parser: exports.string },
+        { parser: exports.identifier },
+    ]),
+    (0, core_1.select)([
+        { prefix: '=', parser: syntax([punctuation('='), { get: () => attributeValue }], true) },
+        { parser: { get: () => attributeTree } },
+    ]),
+], true);
+const attributeTreeNamedValues = (0, core_1.setType)('mcdoc:attribute/tree/named', syntax([
+    attributeNamedValue,
+    syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(attributeNamedValue)], true), true),
+], true));
+const treeBody = (0, core_1.any)([
+    syntax([attributeTreePosValues, (0, core_1.optional)(marker(','))]),
+    syntax([attributeTreeNamedValues, (0, core_1.optional)(marker(','))]),
+    syntax([attributeTreePosValues, punctuation(','), attributeTreeNamedValues, (0, core_1.optional)(marker(','))]),
+]);
+const AttributeTreeClosure = Object.freeze({
+    '(': ')',
+    '[': ']',
+    '{': '}',
+});
+const attributeTree = (src, ctx) => {
+    const delim = src.trySkip('(') ? '(' : (src.trySkip('[') ? '[' : '{');
+    const res = treeBody(src, ctx);
+    const ans = {
+        type: 'mcdoc:attribute/tree',
+        range: res.range,
+        children: res.children,
+        delim,
+    };
+    src.trySkip(AttributeTreeClosure[delim]);
+    return ans;
+};
+const attributeValue = (0, core_1.select)([
+    { predicate: src => ['(', '[', '{'].includes(src.peek()), parser: attributeTree },
+    { parser: { get: () => exports.type } },
+]);
+exports.attribute = (0, core_1.setType)('mcdoc:attribute', syntax([
+    marker('#['),
+    exports.identifier,
+    (0, core_1.select)([
+        { prefix: '=', parser: syntax([punctuation('='), attributeValue, punctuation(']')], true) },
+        { predicate: src => ['(', '[', '{'].includes(src.peek()), parser: syntax([attributeTree, punctuation(']')], true) },
+        { parser: punctuation(']') },
+    ]),
+], true));
+const attributes = (0, core_1.repeat)(exports.attribute);
+exports.dispatchStatement = (0, core_1.setType)('mcdoc:dispatch_statement', syntax([
+    attributes,
+    keyword('dispatch'),
+    resLoc({ category: 'mcdoc/dispatcher', accessType: 1 /* SymbolAccessType.Write */ }),
+    indexBody({ noDynamic: true }),
+    literal('to'),
+    { get: () => exports.type },
+], true));
+exports.docComment = core.comment({
+    singleLinePrefixes: new Set(['///']),
+    includesEol: true,
+});
+exports.docComments = (0, core_1.setType)('mcdoc:doc_comments', (0, core_1.repeat)(exports.docComment, src => {
+    src.skipWhitespace();
+    return [];
+}));
+const prelim = syntax([
+    (0, core_1.optional)((0, core_1.failOnEmpty)(exports.docComments)),
+    attributes,
+]);
+const enumType = literal([
+    'byte',
+    'short',
+    'int',
+    'long',
+    'string',
+    'float',
+    'double',
+], { colorTokenType: 'type' });
+exports.float = core.float({
+    pattern: /^[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)?|[0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?)$/,
+});
+exports.typedNumber = (0, core_1.setType)('mcdoc:typed_number', (0, core_1.sequence)([
+    exports.float,
+    (0, core_1.optional)(keyword(['b', 'B', 'd', 'D', 'f', 'F', 'l', 'L', 's', 'S'], { colorTokenType: 'keyword' })),
+]));
+const enumValue = (0, core_1.select)([
+    { prefix: '"', parser: exports.string },
+    { parser: exports.typedNumber },
+]);
+const enumField = (0, core_1.setType)('mcdoc:enum/field', syntax([
+    prelim,
+    exports.identifier,
+    punctuation('='),
+    enumValue,
+], true));
+const enumBlock = (0, core_1.setType)('mcdoc:enum/block', syntax([
+    punctuation('{'),
+    (0, core_1.select)([
+        { prefix: '}', parser: punctuation('}') },
+        {
+            parser: syntax([
+                enumField,
+                syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(enumField)], true), true),
+                (0, core_1.optional)(marker(',')),
+                punctuation('}'),
+            ], true),
+        },
+    ]),
+], true));
+exports.enum_ = (0, core_1.setType)('mcdoc:enum', syntax([
+    prelim,
+    keyword('enum'),
+    punctuation('('),
+    enumType,
+    punctuation(')'),
+    (0, core_1.optional)((0, core_1.failOnError)(exports.identifier)),
+    enumBlock,
+], true));
+const typeParam = (0, core_1.setType)('mcdoc:type_param', syntax([
+    exports.identifier,
+    (0, core_1.optional)(syntax([(0, core_1.failOnError)(literal('extends')), exports.path])),
+]));
+const typeParamBlock = (0, core_1.setType)('mcdoc:type_param_block', syntax([
+    punctuation('<'),
+    (0, core_1.select)([
+        { prefix: '>', parser: punctuation('>') },
+        {
+            parser: syntax([
+                typeParam,
+                syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(typeParam)])),
+                (0, core_1.optional)(marker(',')),
+                punctuation('>'),
+            ]),
+        },
+    ]),
+]));
+const noop = () => undefined;
+const optionalTypeParamBlock = (0, core_1.select)([
+    { prefix: '<', parser: typeParamBlock },
+    { parser: noop },
+]);
+const structMapKey = (0, core_1.setType)('mcdoc:struct/map_key', syntax([
+    punctuation('['),
+    { get: () => exports.type },
+    punctuation(']'),
+], true));
+const structKey = (0, core_1.select)([
+    { prefix: '"', parser: exports.string },
+    { prefix: '[', parser: structMapKey },
+    { parser: exports.identifier },
+]);
+const structPairField = (src, ctx) => {
+    let isOptional;
+    const result0 = syntax([
+        prelim,
+        structKey,
+    ], true)(src, ctx);
+    if (src.trySkip('?')) {
+        isOptional = true;
+    }
+    const result1 = syntax([
+        punctuation(':'),
+        { get: () => exports.type },
+    ], true)(src, ctx);
+    const ans = {
+        type: 'mcdoc:struct/field/pair',
+        children: [...result0.children, ...result1.children],
+        range: core_1.Range.span(result0, result1),
+        isOptional,
+    };
+    return ans;
+};
+const structSpreadField = (0, core_1.setType)('mcdoc:struct/field/spread', syntax([
+    attributes,
+    marker('...'),
+    { get: () => exports.type },
+], true));
+const structField = (0, core_1.any)([
+    structSpreadField,
+    structPairField,
+]);
+const structBlock = (0, core_1.setType)('mcdoc:struct/block', syntax([
+    punctuation('{'),
+    (0, core_1.select)([
+        { prefix: '}', parser: punctuation('}') },
+        {
+            parser: syntax([
+                structField,
+                syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(structField)], true), true),
+                (0, core_1.optional)(marker(',')),
+                punctuation('}'),
+            ], true),
+        },
+    ]),
+], true));
+exports.struct = (0, core_1.setType)('mcdoc:struct', syntax([
+    prelim,
+    keyword('struct'),
+    (0, core_1.optional)((0, core_1.failOnEmpty)(exports.identifier)),
+    optionalTypeParamBlock,
+    structBlock,
+], true));
+const enumInjection = (0, core_1.setType)('mcdoc:injection/enum', syntax([
+    literal('enum'),
+    punctuation('('),
+    enumType,
+    punctuation(')'),
+    exports.path,
+    enumBlock,
+]));
+const structInjection = (0, core_1.setType)('mcdoc:injection/struct', syntax([
+    literal('struct'),
+    exports.path,
+    optionalTypeParamBlock,
+    structBlock,
+]));
+exports.injection = (0, core_1.setType)('mcdoc:injection', syntax([
+    keyword('inject'),
+    (0, core_1.select)([
+        { prefix: 'enum', parser: enumInjection },
+        { parser: structInjection },
+    ]),
+]));
+exports.typeAlias = (0, core_1.setType)('mcdoc:type_alias', syntax([
+    prelim,
+    keyword('type'),
+    exports.identifier,
+    optionalTypeParamBlock,
+    punctuation('='),
+    { get: () => exports.type },
+], true));
+exports.useStatement = (0, core_1.setType)('mcdoc:use_statement', syntax([
+    keyword('use'),
+    exports.path,
+    (0, core_1.select)([
+        { prefix: 'as', parser: syntax([literal('as'), exports.identifier]) },
+        { parser: noop },
+    ]),
+]));
+const topLevel = (0, core_1.any)([
+    exports.comment,
+    exports.dispatchStatement,
+    exports.enum_,
+    exports.injection,
+    exports.struct,
+    exports.typeAlias,
+    exports.useStatement,
+]);
+exports.module_ = (0, core_1.setType)('mcdoc:module', syntaxRepeat(topLevel, true));
+/* eslint-enable @typescript-eslint/indent */
+function typeBase(type, parser) {
+    return (0, core_1.setType)(type, syntax([
+        attributes,
+        parser,
+        syntaxRepeat((0, core_1.failOnError)(indexBody())),
+    ], true));
+}
+exports.anyType = typeBase('mcdoc:type/any', keyword('any', { colorTokenType: 'type' }));
+exports.booleanType = typeBase('mcdoc:type/boolean', keyword('boolean', { colorTokenType: 'type' }));
+exports.integer = core.integer({
+    pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
+});
+function range(type, number) {
+    return (0, core_1.setType)(type, (0, core_1.select)([
+        {
+            prefix: '..',
+            parser: (0, core_1.sequence)([
+                literal('..', { allowedChars: new Set('.') }),
+                number,
+            ]),
+        },
+        {
+            parser: (0, core_1.sequence)([
+                (0, core_1.stopBefore)(number, '..'),
+                (0, core_1.select)([
+                    {
+                        prefix: '..',
+                        parser: (0, core_1.sequence)([
+                            literal('..', { allowedChars: new Set('.') }),
+                            (0, core_1.optional)((0, core_1.failOnEmpty)(number)),
+                        ]),
+                    },
+                    { parser: noop },
+                ]),
+            ]),
+        },
+    ]));
+}
+const intRange = range('mcdoc:int_range', exports.integer);
+const atIntRange = (0, core_1.optional)((src, ctx) => {
+    if (!src.trySkip('@')) {
+        return core_1.Failure;
+    }
+    src.skipWhitespace();
+    return intRange(src, ctx);
+});
+exports.stringType = typeBase('mcdoc:type/string', syntax([
+    keyword('string', { colorTokenType: 'type' }),
+    atIntRange,
+]));
+exports.literalType = typeBase('mcdoc:type/literal', (0, core_1.select)([
+    { predicate: src => src.tryPeek('false') || src.tryPeek('true'), parser: keyword(['false', 'true'], { colorTokenType: 'type' }) },
+    { prefix: '"', parser: (0, core_1.failOnEmpty)(exports.string) },
+    { parser: (0, core_1.failOnError)(exports.typedNumber) },
+]));
+const floatRange = range('mcdoc:float_range', exports.float);
+const atFloatRange = (0, core_1.optional)((src, ctx) => {
+    if (!src.trySkip('@')) {
+        return core_1.Failure;
+    }
+    src.skipWhitespace();
+    return floatRange(src, ctx);
+});
+exports.numericType = typeBase('mcdoc:type/numeric_type', (0, core_1.select)([
+    {
+        predicate: src => src.tryPeek('float') || src.tryPeek('double'),
+        parser: syntax([
+            keyword(['float', 'double'], { colorTokenType: 'type' }),
+            atFloatRange,
+        ]),
+    },
+    {
+        parser: syntax([
+            keyword(['byte', 'short', 'int', 'long'], { colorTokenType: 'type' }),
+            atIntRange,
+        ]),
+    },
+]));
+exports.primitiveArrayType = typeBase('mcdoc:type/primitive_array', syntax([
+    literal(['byte', 'int', 'long']),
+    atIntRange,
+    keyword('[]', { allowedChars: new Set(['[', ']']), colorTokenType: 'type' }),
+    atIntRange,
+]));
+exports.listType = typeBase('mcdoc:type/list', syntax([
+    marker('['),
+    { get: () => exports.type },
+    punctuation(']'),
+    atIntRange,
+], true));
+exports.tupleType = typeBase('mcdoc:type/tuple', syntax([
+    marker('['),
+    { get: () => exports.type },
+    marker(','),
+    (0, core_1.select)([
+        { prefix: ']', parser: punctuation(']') },
+        {
+            parser: syntax([
+                { get: () => exports.type },
+                syntaxRepeat(syntax([marker(','), { get: () => (0, core_1.failOnEmpty)(exports.type) }], true), true),
+                (0, core_1.optional)(marker(',')),
+                punctuation(']'),
+            ], true),
+        },
+    ]),
+], true));
+exports.dispatcherType = typeBase('mcdoc:type/dispatcher', syntax([
+    (0, core_1.failOnError)(resLoc({ category: 'mcdoc/dispatcher' })),
+    indexBody(),
+]));
+exports.unionType = typeBase('mcdoc:type/union', syntax([
+    marker('('),
+    (0, core_1.select)([
+        { prefix: ')', parser: punctuation(')') },
+        {
+            parser: syntax([
+                { get: () => exports.type },
+                syntaxRepeat(syntax([marker('|'), { get: () => (0, core_1.failOnEmpty)(exports.type) }], true), true),
+                (0, core_1.optional)(marker('|')),
+                punctuation(')'),
+            ], true),
+        },
+    ]),
+]));
+exports.pathType = typeBase('mcdoc:type/path', syntax([
+    exports.path,
+    (0, core_1.optional)(syntax([
+        marker('<'),
+        (0, core_1.select)([
+            { prefix: '>', parser: punctuation('>') },
+            {
+                parser: syntax([
+                    { get: () => exports.type },
+                    syntaxRepeat(syntax([marker(','), { get: () => (0, core_1.failOnEmpty)(exports.type) }], true), true),
+                    (0, core_1.optional)(marker(',')),
+                    punctuation('>'),
+                ], true),
+            },
+        ]),
+    ])),
+]));
+exports.type = (0, core_1.any)([
+    exports.anyType,
+    exports.booleanType,
+    exports.dispatcherType,
+    exports.enum_,
+    exports.listType,
+    exports.literalType,
+    exports.numericType,
+    exports.primitiveArrayType,
+    exports.stringType,
+    exports.struct,
+    exports.tupleType,
+    exports.unionType,
+    exports.pathType,
+]);
+//# sourceMappingURL=index.js.map