xhs-mp-pack 1.1.0-beta.0

package/dist/base/errors/ModuleHashingError.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class ModuleHashingError extends BaseError_1.default {
+    constructor(module, error) {
+        super();
+        this.name = 'ModuleHashingError';
+        this.error = error;
+        this.message = error.message;
+        this.details = error.stack;
+        this.module = module;
+    }
+}
+exports.default = ModuleHashingError;

package/dist/base/errors/ModuleNotFoundError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class ModuleNotFoundError extends BaseError {
+    constructor(module: any, err: any, loc: any);
+}
+export default ModuleNotFoundError;

package/dist/base/errors/ModuleNotFoundError.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const previouslyPolyfilledBuiltinModules = {
+    assert: 'assert/',
+    buffer: 'buffer/',
+    console: 'console-browserify',
+    constants: 'constants-browserify',
+    crypto: 'crypto-browserify',
+    domain: 'domain-browser',
+    events: 'events/',
+    http: 'stream-http',
+    https: 'https-browserify',
+    os: 'os-browserify/browser',
+    path: 'path-browserify',
+    punycode: 'punycode/',
+    process: 'process/browser',
+    querystring: 'querystring-es3',
+    stream: 'stream-browserify',
+    _stream_duplex: 'readable-stream/duplex',
+    _stream_passthrough: 'readable-stream/passthrough',
+    _stream_readable: 'readable-stream/readable',
+    _stream_transform: 'readable-stream/transform',
+    _stream_writable: 'readable-stream/writable',
+    string_decoder: 'string_decoder/',
+    sys: 'util/',
+    timers: 'timers-browserify',
+    tty: 'tty-browserify',
+    url: 'url/',
+    util: 'util/',
+    vm: 'vm-browserify',
+    zlib: 'browserify-zlib',
+};
+class ModuleNotFoundError extends BaseError_1.default {
+    constructor(module, err, loc) {
+        let message = `Module not found: ${err.toString()}`;
+        const match = err.message.match(/Can't resolve '([^']+)'/);
+        if (match) {
+            const request = match[1];
+            const alias = previouslyPolyfilledBuiltinModules[request];
+            if (alias) {
+                const pathIndex = alias.indexOf('/');
+                const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
+                message +=
+                    '\n\n' +
+                        'BREAKING CHANGE: ' +
+                        'webpack < 5 used to include polyfills for node.js core modules by default.\n' +
+                        'This is no longer the case. Verify if you need this module and configure a polyfill for it.\n\n';
+                message +=
+                    'If you want to include a polyfill, you need to:\n' +
+                        `\t- add a fallback 'resolve.fallback: { "${request}": require.resolve("${alias}") }'\n` +
+                        `\t- install '${dependency}'\n`;
+                message +=
+                    "If you don't want to include a polyfill, you can use an empty module like this:\n" +
+                        `\tresolve.fallback: { "${request}": false }`;
+            }
+        }
+        super(message);
+        this.name = 'ModuleNotFoundError';
+        this.details = err.details;
+        this.module = module;
+        this.error = err;
+        this.loc = loc;
+    }
+}
+exports.default = ModuleNotFoundError;

package/dist/base/errors/ModuleParseError.d.ts

@@ -0,0 +1,8 @@
+import BaseError from './BaseError';
+declare class ModuleParseError extends BaseError {
+    error: any;
+    constructor(source: any, err: any, loaders: any, type: any);
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ModuleParseError;

package/dist/base/errors/ModuleParseError.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
+class ModuleParseError extends BaseError_1.default {
+    constructor(source, err, loaders, type) {
+        let message = `Module parse failed: ${err === null || err === void 0 ? void 0 : err.message}`;
+        let loc;
+        if (((Buffer.isBuffer(source) && source.slice(0, 4).equals(WASM_HEADER)) ||
+            (typeof source === 'string' && /^\0asm/.test(source))) &&
+            !type.startsWith('webassembly')) {
+            message +=
+                '\nThe module seem to be a WebAssembly module, but module is not flagged as WebAssembly module for webpack.';
+            message +=
+                '\nBREAKING CHANGE: Since webpack 5 WebAssembly is not enabled by default and flagged as experimental feature.';
+            message +=
+                "\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
+            message +=
+                "\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
+        }
+        else if (!loaders) {
+            message += '\nYou may need an appropriate loader to handle this file type.';
+        }
+        else if (loaders.length >= 1) {
+            message += `\nFile was processed with these loaders:${loaders
+                .map(loader => `\n * ${loader}`)
+                .join('')}`;
+            message += '\nYou may need an additional loader to handle the result of these loaders.';
+        }
+        else {
+            message +=
+                '\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders';
+        }
+        if ((err === null || err === void 0 ? void 0 : err.loc) && typeof err.loc === 'object' && typeof err.loc.line === 'number') {
+            const lineNumber = err.loc.line;
+            if (Buffer.isBuffer(source) ||
+                // eslint-disable-next-line no-control-regex
+                /[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)) {
+                // binary file
+                message += '\n(Source code omitted for this binary file)';
+            }
+            else {
+                const sourceLines = source.split(/\r?\n/);
+                const start = Math.max(0, lineNumber - 3);
+                const linesBefore = sourceLines.slice(start, lineNumber - 1);
+                const theLine = sourceLines[lineNumber - 1];
+                const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
+                message +=
+                    `${linesBefore.map(l => `\n| ${l}`).join('')}\n> ${theLine}${linesAfter.map(l => `\n| ${l}`).join('')}`;
+            }
+            loc = { start: err.loc };
+        }
+        else if (err === null || err === void 0 ? void 0 : err.stack) {
+            message += `\n${err.stack}`;
+        }
+        super(message);
+        this.name = 'ModuleParseError';
+        this.loc = loc;
+        this.error = err;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.error);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.error = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ModuleParseError, 'mp-compiler/base/errors/ModuleParseError');
+exports.default = ModuleParseError;

package/dist/base/errors/ModuleRestoreError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class ModuleRestoreError extends BaseError {
+    constructor(module: any, err: string | Error);
+}
+export default ModuleRestoreError;

package/dist/base/errors/ModuleRestoreError.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class ModuleRestoreError extends BaseError_1.default {
+    constructor(module, err) {
+        let message = 'Module restore failed: ';
+        const details = undefined;
+        if (err !== null && typeof err === 'object') {
+            if (typeof err.stack === 'string' && err.stack) {
+                const stack = err.stack;
+                message += stack;
+            }
+            else if (typeof err.message === 'string' && err.message) {
+                message += err.message;
+            }
+            else {
+                message += err;
+            }
+        }
+        else {
+            message += String(err);
+        }
+        super(message);
+        this.name = 'ModuleRestoreError';
+        this.details = details;
+        this.module = module;
+        this.error = err;
+    }
+}
+exports.default = ModuleRestoreError;

package/dist/base/errors/ModuleStoreError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class ModuleStoreError extends BaseError {
+    constructor(module: any, err: string | Error);
+}
+export default ModuleStoreError;

package/dist/base/errors/ModuleStoreError.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class ModuleStoreError extends BaseError_1.default {
+    constructor(module, err) {
+        let message = 'Module storing failed: ';
+        const details = undefined;
+        if (err !== null && typeof err === 'object') {
+            if (typeof err.stack === 'string' && err.stack) {
+                const stack = err.stack;
+                message += stack;
+            }
+            else if (typeof err.message === 'string' && err.message) {
+                message += err.message;
+            }
+            else {
+                message += err;
+            }
+        }
+        else {
+            message += String(err);
+        }
+        super(message);
+        this.name = 'ModuleStoreError';
+        this.details = details;
+        this.module = module;
+        this.error = err;
+    }
+}
+exports.default = ModuleStoreError;

package/dist/base/errors/ModuleWarning.d.ts

@@ -0,0 +1,10 @@
+import BaseError from './BaseError';
+declare class ModuleWarning extends BaseError {
+    warning: any;
+    constructor(warning: any, { from }?: {
+        from?: null | undefined;
+    });
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ModuleWarning;

package/dist/base/errors/ModuleWarning.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ErrorHelpers_1 = require("./ErrorHelpers");
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class ModuleWarning extends BaseError_1.default {
+    constructor(warning, { from = null } = {}) {
+        let message = 'Module Warning';
+        if (from) {
+            message += ` (from ${from}):\n`;
+        }
+        else {
+            message += ': ';
+        }
+        if (warning && typeof warning === 'object' && warning.message) {
+            message += warning.message;
+        }
+        else if (warning) {
+            message += String(warning);
+        }
+        super(message);
+        this.name = 'ModuleWarning';
+        this.warning = warning;
+        this.details =
+            warning && typeof warning === 'object' && warning.stack
+                ? (0, ErrorHelpers_1.cleanUp)(warning.stack, this.message)
+                : undefined;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.warning);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.warning = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ModuleWarning, 'mp-compiler/base/errors/ModuleWarning');
+exports.default = ModuleWarning;

package/dist/base/errors/NodeStuffInWebError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class NodeStuffInWebError extends BaseError {
+    constructor(loc: any, expression: string, description: string);
+}
+export default NodeStuffInWebError;

package/dist/base/errors/NodeStuffInWebError.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class NodeStuffInWebError extends BaseError_1.default {
+    constructor(loc, expression, description) {
+        super(`${JSON.stringify(expression)} has been used, it will be undefined in next major version.
+${description}`);
+        this.name = 'NodeStuffInWebError';
+        this.loc = loc;
+    }
+}
+(0, makeSerializable_1.default)(NodeStuffInWebError, 'mp-compiler/base/errors/NodeStuffInWebError');
+exports.default = NodeStuffInWebError;

package/dist/base/errors/UnhandledSchemeError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class UnhandledSchemeError extends BaseError {
+    constructor(scheme: string, resource: string);
+}
+export default UnhandledSchemeError;

package/dist/base/errors/UnhandledSchemeError.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class UnhandledSchemeError extends BaseError_1.default {
+    constructor(scheme, resource) {
+        super(`Reading from "${resource}" is not handled by plugins (Unhandled scheme).` +
+            '\nWebpack supports "data:" and "file:" URIs by default.' +
+            `\nYou may need an additional plugin to handle "${scheme}:" URIs.`);
+        this.file = resource;
+        this.name = 'UnhandledSchemeError';
+    }
+}
+(0, makeSerializable_1.default)(UnhandledSchemeError, 'mp-compiler/base/errors/UnhandledSchemeError', 'UnhandledSchemeError');
+exports.default = UnhandledSchemeError;

package/dist/base/errors/UnsupportedFeatureWarning.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class UnsupportedFeatureWarning extends BaseError {
+    constructor(message: any, loc: any);
+}
+export default UnsupportedFeatureWarning;

package/dist/base/errors/UnsupportedFeatureWarning.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class UnsupportedFeatureWarning extends BaseError_1.default {
+    constructor(message, loc) {
+        super(message);
+        this.name = 'UnsupportedFeatureWarning';
+        this.loc = loc;
+        this.hideStack = true;
+    }
+}
+(0, makeSerializable_1.default)(UnsupportedFeatureWarning, 'mp-compiler/base/errors/UnsupportedFeatureWarning');
+exports.default = UnsupportedFeatureWarning;

package/dist/base/extractUrlAndGlobal.d.ts

@@ -0,0 +1 @@
+export default function extractUrlAndGlobal(urlAndGlobal: string): string[];

package/dist/base/extractUrlAndGlobal.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function extractUrlAndGlobal(urlAndGlobal) {
+    const index = urlAndGlobal.indexOf('@');
+    if (index <= 0 || index === urlAndGlobal.length - 1) {
+        throw new Error(`Invalid request "${urlAndGlobal}"`);
+    }
+    return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
+}
+exports.default = extractUrlAndGlobal;

package/dist/base/findGraphRoots.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (items: any, getDependencies: any) => any;
+export default _default;

package/dist/base/findGraphRoots.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NO_MARKER = 0;
+const IN_PROGRESS_MARKER = 1;
+const DONE_MARKER = 2;
+const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
+const DONE_AND_ROOT_MARKER = 4;
+/**
+ * @template T
+ */
+class Node {
+    constructor(item) {
+        this.item = item;
+        this.dependencies = new Set();
+        this.marker = NO_MARKER;
+        this.cycle = undefined;
+        this.incoming = 0;
+    }
+}
+class Cycle {
+    constructor() {
+        this.nodes = new Set();
+    }
+}
+exports.default = (items, getDependencies) => {
+    const itemToNode = new Map();
+    for (const item of items) {
+        const node = new Node(item);
+        itemToNode.set(item, node);
+    }
+    // early exit when there is only a single item
+    if (itemToNode.size <= 1)
+        return items;
+    // grab all the dependencies
+    for (const node of itemToNode.values()) {
+        for (const dep of getDependencies(node.item)) {
+            const depNode = itemToNode.get(dep);
+            if (depNode !== undefined) {
+                node.dependencies.add(depNode);
+            }
+        }
+    }
+    // Set of current root modules
+    // items will be removed if a new reference to it has been found
+    const roots = new Set();
+    // Set of current cycles without references to it
+    // cycles will be removed if a new reference to it has been found
+    // that is not part of the cycle
+    const rootCycles = new Set();
+    // For all non-marked nodes
+    for (const selectedNode of itemToNode.values()) {
+        if (selectedNode.marker === NO_MARKER) {
+            // deep-walk all referenced modules
+            // in a non-recursive way
+            // start by entering the selected node
+            selectedNode.marker = IN_PROGRESS_MARKER;
+            // keep a stack to avoid recursive walk
+            const stack = [
+                {
+                    node: selectedNode,
+                    openEdges: Array.from(selectedNode.dependencies),
+                },
+            ];
+            // process the top item until stack is empty
+            while (stack.length > 0) {
+                const topOfStack = stack[stack.length - 1];
+                // Are there still edges unprocessed in the current node?
+                if (topOfStack.openEdges.length > 0) {
+                    // Process one dependency
+                    const dependency = topOfStack.openEdges.pop();
+                    switch (dependency.marker) {
+                        case NO_MARKER:
+                            // dependency has not be visited yet
+                            // mark it as in-progress and recurse
+                            stack.push({
+                                node: dependency,
+                                openEdges: Array.from(dependency.dependencies),
+                            });
+                            dependency.marker = IN_PROGRESS_MARKER;
+                            break;
+                        case IN_PROGRESS_MARKER: {
+                            // It's a in-progress cycle
+                            let cycle = dependency.cycle;
+                            if (!cycle) {
+                                cycle = new Cycle();
+                                cycle.nodes.add(dependency);
+                                dependency.cycle = cycle;
+                            }
+                            // set cycle property for each node in the cycle
+                            // if nodes are already part of a cycle
+                            // we merge the cycles to a shared cycle
+                            for (let i = stack.length - 1; stack[i].node !== dependency; i--) {
+                                const node = stack[i].node;
+                                if (node.cycle) {
+                                    if (node.cycle !== cycle) {
+                                        // merge cycles
+                                        for (const cycleNode of node.cycle.nodes) {
+                                            cycleNode.cycle = cycle;
+                                            cycle.nodes.add(cycleNode);
+                                        }
+                                    }
+                                }
+                                else {
+                                    node.cycle = cycle;
+                                    cycle.nodes.add(node);
+                                }
+                            }
+                            // don't recurse into dependencies
+                            // these are already on the stack
+                            break;
+                        }
+                        case DONE_AND_ROOT_MARKER:
+                            // This node has be visited yet and is currently a root node
+                            // But as this is a new reference to the node
+                            // it's not really a root
+                            // so we have to convert it to a normal node
+                            dependency.marker = DONE_MARKER;
+                            roots.delete(dependency);
+                            break;
+                        case DONE_MAYBE_ROOT_CYCLE_MARKER:
+                            // This node has be visited yet and
+                            // is maybe currently part of a completed root cycle
+                            // we found a new reference to the cycle
+                            // so it's not really a root cycle
+                            // remove the cycle from the root cycles
+                            // and convert it to a normal node
+                            rootCycles.delete(dependency.cycle);
+                            dependency.marker = DONE_MARKER;
+                            break;
+                        // DONE_MARKER: nothing to do, don't recurse into dependencies
+                    }
+                }
+                else {
+                    // All dependencies of the current node has been visited
+                    // we leave the node
+                    stack.pop();
+                    topOfStack.node.marker = DONE_MARKER;
+                }
+            }
+            const cycle = selectedNode.cycle;
+            if (cycle) {
+                for (const node of cycle.nodes) {
+                    node.marker = DONE_MAYBE_ROOT_CYCLE_MARKER;
+                }
+                rootCycles.add(cycle);
+            }
+            else {
+                selectedNode.marker = DONE_AND_ROOT_MARKER;
+                roots.add(selectedNode);
+            }
+        }
+    }
+    // Extract roots from root cycles
+    // We take the nodes with most incoming edges
+    // inside of the cycle
+    for (const cycle of rootCycles) {
+        let max = 0;
+        const cycleRoots = new Set();
+        const nodes = cycle.nodes;
+        for (const node of nodes) {
+            for (const dep of node.dependencies) {
+                if (nodes.has(dep)) {
+                    dep.incoming++;
+                    if (dep.incoming < max)
+                        continue;
+                    if (dep.incoming > max) {
+                        cycleRoots.clear();
+                        max = dep.incoming;
+                    }
+                    cycleRoots.add(dep);
+                }
+            }
+        }
+        for (const cycleRoot of cycleRoots) {
+            roots.add(cycleRoot);
+        }
+    }
+    // When roots were found, return them
+    if (roots.size > 0) {
+        return Array.from(roots, (r) => r.item);
+    }
+    throw new Error('Implementation of findGraphRoots is broken');
+};

package/dist/base/formatLocation.d.ts

@@ -0,0 +1,2 @@
+declare const formatLocation: (loc: any) => any;
+export default formatLocation;

package/dist/base/formatLocation.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatPosition = pos => {
+    if (pos && typeof pos === 'object') {
+        if ('line' in pos && 'column' in pos) {
+            return `${pos.line}:${pos.column}`;
+        }
+        if ('line' in pos) {
+            return `${pos.line}:?`;
+        }
+    }
+    return '';
+};
+const formatLocation = loc => {
+    if (loc && typeof loc === 'object') {
+        if ('start' in loc && loc.start && 'end' in loc && loc.end) {
+            if (typeof loc.start === 'object' &&
+                typeof loc.start.line === 'number' &&
+                typeof loc.end === 'object' &&
+                typeof loc.end.line === 'number' &&
+                typeof loc.end.column === 'number' &&
+                loc.start.line === loc.end.line) {
+                return `${formatPosition(loc.start)}-${loc.end.column}`;
+            }
+            if (typeof loc.start === 'object' &&
+                typeof loc.start.line === 'number' &&
+                typeof loc.start.column !== 'number' &&
+                typeof loc.end === 'object' &&
+                typeof loc.end.line === 'number' &&
+                typeof loc.end.column !== 'number') {
+                return `${loc.start.line}-${loc.end.line}`;
+            }
+            return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+        }
+        if ('start' in loc && loc.start) {
+            return formatPosition(loc.start);
+        }
+        if ('name' in loc && 'index' in loc) {
+            return `${loc.name}[${loc.index}]`;
+        }
+        if ('name' in loc) {
+            return loc.name;
+        }
+    }
+    return '';
+};
+exports.default = formatLocation;