.

node_modules/next/dist/esm/server/route-matcher-providers/dev/dev-app-page-route-matcher-provider.js

@@ -0,0 +1,81 @@
+import { AppPageRouteMatcher } from '../../route-matchers/app-page-route-matcher';
+import { RouteKind } from '../../route-kind';
+import { FileCacheRouteMatcherProvider } from './file-cache-route-matcher-provider';
+import { DevAppNormalizers } from '../../normalizers/built/app';
+import { normalizeCatchAllRoutes } from '../../../build/normalize-catchall-routes';
+import { compareAppPaths } from '../../../shared/lib/router/utils/app-paths';
+export class DevAppPageRouteMatcherProvider extends FileCacheRouteMatcherProvider {
+    constructor(appDir, extensions, reader, isTurbopack){
+        super(appDir, reader);
+        this.normalizers = new DevAppNormalizers(appDir, extensions, isTurbopack);
+        // Match any page file that ends with `/page.${extension}` or `/default.${extension}` under the app
+        // directory.
+        this.expression = new RegExp(`[/\\\\](page|default)\\.(?:${extensions.join('|')})$`);
+        this.isTurbopack = isTurbopack;
+    }
+    async transform(files) {
+        // Collect all the app paths for each page. This could include any parallel
+        // routes.
+        const cache = new Map();
+        const routeFilenames = new Array();
+        let appPaths = {};
+        for (const filename of files){
+            // If the file isn't a match for this matcher, then skip it.
+            if (!this.expression.test(filename)) continue;
+            let page = this.normalizers.page.normalize(filename);
+            // Validate that this is not an ignored page.
+            if (page.includes('/_')) continue;
+            // Turbopack uses the correct page name with the underscore normalized.
+            // TODO: Move implementation to packages/next/src/server/normalizers/built/app/app-page-normalizer.ts.
+            // The `includes('/_')` check above needs to be moved for that to work as otherwise `%5Fsegmentname`
+            // will result in `_segmentname` which hits that includes check and be skipped.
+            if (this.isTurbopack) {
+                page = page.replace(/%5F/g, '_');
+            }
+            // This is a valid file that we want to create a matcher for.
+            routeFilenames.push(filename);
+            const pathname = this.normalizers.pathname.normalize(filename);
+            const bundlePath = this.normalizers.bundlePath.normalize(filename);
+            // Save the normalization results.
+            cache.set(filename, {
+                page,
+                pathname,
+                bundlePath
+            });
+            if (pathname in appPaths) appPaths[pathname].push(page);
+            else appPaths[pathname] = [
+                page
+            ];
+        }
+        normalizeCatchAllRoutes(appPaths);
+        // Make sure to sort parallel routes to make the result deterministic.
+        appPaths = Object.fromEntries(Object.entries(appPaths).map(([k, v])=>[
+                k,
+                v.sort(compareAppPaths)
+            ]));
+        const matchers = [];
+        for (const filename of routeFilenames){
+            // Grab the cached values (and the appPaths).
+            const cached = cache.get(filename);
+            if (!cached) {
+                throw Object.defineProperty(new Error('Invariant: expected filename to exist in cache'), "__NEXT_ERROR_CODE", {
+                    value: "E190",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            const { pathname, page, bundlePath } = cached;
+            matchers.push(new AppPageRouteMatcher({
+                kind: RouteKind.APP_PAGE,
+                pathname,
+                page,
+                bundlePath,
+                filename,
+                appPaths: appPaths[pathname]
+            }));
+        }
+        return matchers;
+    }
+}
+
+//# sourceMappingURL=dev-app-page-route-matcher-provider.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/dev-app-route-route-matcher-provider.js

@@ -0,0 +1,97 @@
+import { AppRouteRouteMatcher } from '../../route-matchers/app-route-route-matcher';
+import { RouteKind } from '../../route-kind';
+import { FileCacheRouteMatcherProvider } from './file-cache-route-matcher-provider';
+import { isAppRouteRoute } from '../../../lib/is-app-route-route';
+import { DevAppNormalizers } from '../../normalizers/built/app';
+import { isMetadataRouteFile, isStaticMetadataRoute, isStaticMetadataFile } from '../../../lib/metadata/is-metadata-route';
+import { normalizeMetadataPageToRoute } from '../../../lib/metadata/get-metadata-route';
+import path from '../../../shared/lib/isomorphic/path';
+export class DevAppRouteRouteMatcherProvider extends FileCacheRouteMatcherProvider {
+    constructor(appDir, extensions, reader, isTurbopack){
+        super(appDir, reader);
+        this.appDir = appDir;
+        this.isTurbopack = isTurbopack;
+        this.normalizers = new DevAppNormalizers(appDir, extensions, isTurbopack);
+    }
+    async transform(files) {
+        const matchers = [];
+        for (const filename of files){
+            // Skip static metadata files as they are served from filesystem.
+            if (isStaticMetadataFile(filename.replace(this.appDir, ''))) {
+                continue;
+            }
+            let page = this.normalizers.page.normalize(filename);
+            // If the file isn't a match for this matcher, then skip it.
+            if (!isAppRouteRoute(page)) continue;
+            // Validate that this is not an ignored page.
+            if (page.includes('/_')) continue;
+            // Turbopack uses the correct page name with the underscore normalized.
+            // TODO: Move implementation to packages/next/src/server/normalizers/built/app/app-page-normalizer.ts.
+            // The `includes('/_')` check above needs to be moved for that to work as otherwise `%5Fsegmentname`
+            // will result in `_segmentname` which hits that includes check and be skipped.
+            if (this.isTurbopack) {
+                page = page.replace(/%5F/g, '_');
+            }
+            const pathname = this.normalizers.pathname.normalize(filename);
+            const bundlePath = this.normalizers.bundlePath.normalize(filename);
+            const ext = path.extname(filename).slice(1);
+            const isEntryMetadataRouteFile = isMetadataRouteFile(filename.replace(this.appDir, ''), [
+                ext
+            ], true);
+            if (isEntryMetadataRouteFile && !isStaticMetadataRoute(page)) {
+                // Matching dynamic metadata routes.
+                // Add 2 possibilities for both single and multiple routes:
+                {
+                    // single:
+                    // /sitemap.ts -> /sitemap.xml/route
+                    // /icon.ts -> /icon/route
+                    // We'll map the filename before normalization:
+                    // sitemap.ts -> sitemap.xml/route.ts
+                    // icon.ts -> icon/route.ts
+                    const metadataPage = normalizeMetadataPageToRoute(page, false);
+                    const metadataPathname = normalizeMetadataPageToRoute(pathname, false);
+                    const metadataBundlePath = normalizeMetadataPageToRoute(bundlePath, false);
+                    const matcher = new AppRouteRouteMatcher({
+                        kind: RouteKind.APP_ROUTE,
+                        page: metadataPage,
+                        pathname: metadataPathname,
+                        bundlePath: metadataBundlePath,
+                        filename
+                    });
+                    matchers.push(matcher);
+                }
+                {
+                    // multiple:
+                    // /sitemap.ts -> /sitemap/[__metadata_id__]/route
+                    // /icon.ts -> /icon/[__metadata_id__]/route
+                    // We'll map the filename before normalization:
+                    // sitemap.ts -> sitemap.xml/[__metadata_id__].ts
+                    // icon.ts -> icon/[__metadata_id__].ts
+                    const metadataPage = normalizeMetadataPageToRoute(page, true);
+                    const metadataPathname = normalizeMetadataPageToRoute(pathname, true);
+                    const metadataBundlePath = normalizeMetadataPageToRoute(bundlePath, true);
+                    const matcher = new AppRouteRouteMatcher({
+                        kind: RouteKind.APP_ROUTE,
+                        page: metadataPage,
+                        pathname: metadataPathname,
+                        bundlePath: metadataBundlePath,
+                        filename
+                    });
+                    matchers.push(matcher);
+                }
+            } else {
+                // Normal app routes.
+                matchers.push(new AppRouteRouteMatcher({
+                    kind: RouteKind.APP_ROUTE,
+                    page,
+                    pathname,
+                    bundlePath,
+                    filename
+                }));
+            }
+        }
+        return matchers;
+    }
+}
+
+//# sourceMappingURL=dev-app-route-route-matcher-provider.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/dev-pages-api-route-matcher-provider.js

@@ -0,0 +1,62 @@
+import { PagesAPILocaleRouteMatcher, PagesAPIRouteMatcher } from '../../route-matchers/pages-api-route-matcher';
+import { RouteKind } from '../../route-kind';
+import path from 'path';
+import { FileCacheRouteMatcherProvider } from './file-cache-route-matcher-provider';
+import { DevPagesNormalizers } from '../../normalizers/built/pages';
+export class DevPagesAPIRouteMatcherProvider extends FileCacheRouteMatcherProvider {
+    constructor(pagesDir, extensions, reader, localeNormalizer){
+        super(pagesDir, reader), this.pagesDir = pagesDir, this.extensions = extensions, this.localeNormalizer = localeNormalizer;
+        // Match any route file that ends with `/${filename}.${extension}` under the
+        // pages directory.
+        this.expression = new RegExp(`\\.(?:${extensions.join('|')})$`);
+        this.normalizers = new DevPagesNormalizers(pagesDir, extensions);
+    }
+    test(filename) {
+        // If the file does not end in the correct extension it's not a match.
+        if (!this.expression.test(filename)) return false;
+        // Pages API routes must exist in the pages directory with the `/api/`
+        // prefix. The pathnames being tested here though are the full filenames,
+        // so we need to include the pages directory.
+        // TODO: could path separator normalization be needed here?
+        if (filename.startsWith(path.join(this.pagesDir, '/api/'))) return true;
+        for (const extension of this.extensions){
+            // We can also match if we have `pages/api.${extension}`, so check to
+            // see if it's a match.
+            if (filename === path.join(this.pagesDir, `api.${extension}`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async transform(files) {
+        const matchers = [];
+        for (const filename of files){
+            // If the file isn't a match for this matcher, then skip it.
+            if (!this.test(filename)) continue;
+            const pathname = this.normalizers.pathname.normalize(filename);
+            const page = this.normalizers.page.normalize(filename);
+            const bundlePath = this.normalizers.bundlePath.normalize(filename);
+            if (this.localeNormalizer) {
+                matchers.push(new PagesAPILocaleRouteMatcher({
+                    kind: RouteKind.PAGES_API,
+                    pathname,
+                    page,
+                    bundlePath,
+                    filename,
+                    i18n: {}
+                }));
+            } else {
+                matchers.push(new PagesAPIRouteMatcher({
+                    kind: RouteKind.PAGES_API,
+                    pathname,
+                    page,
+                    bundlePath,
+                    filename
+                }));
+            }
+        }
+        return matchers;
+    }
+}
+
+//# sourceMappingURL=dev-pages-api-route-matcher-provider.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/dev-pages-route-matcher-provider.js

@@ -0,0 +1,62 @@
+import { PagesRouteMatcher, PagesLocaleRouteMatcher } from '../../route-matchers/pages-route-matcher';
+import { RouteKind } from '../../route-kind';
+import path from 'path';
+import { FileCacheRouteMatcherProvider } from './file-cache-route-matcher-provider';
+import { DevPagesNormalizers } from '../../normalizers/built/pages';
+export class DevPagesRouteMatcherProvider extends FileCacheRouteMatcherProvider {
+    constructor(pagesDir, extensions, reader, localeNormalizer){
+        super(pagesDir, reader), this.pagesDir = pagesDir, this.extensions = extensions, this.localeNormalizer = localeNormalizer;
+        // Match any route file that ends with `/${filename}.${extension}` under the
+        // pages directory.
+        this.expression = new RegExp(`\\.(?:${extensions.join('|')})$`);
+        this.normalizers = new DevPagesNormalizers(pagesDir, extensions);
+    }
+    test(filename) {
+        // If the file does not end in the correct extension it's not a match.
+        if (!this.expression.test(filename)) return false;
+        // Pages routes must exist in the pages directory without the `/api/`
+        // prefix. The pathnames being tested here though are the full filenames,
+        // so we need to include the pages directory.
+        // TODO: could path separator normalization be needed here?
+        if (filename.startsWith(path.join(this.pagesDir, '/api/'))) return false;
+        for (const extension of this.extensions){
+            // We can also match if we have `pages/api.${extension}`, so check to
+            // see if it's a match.
+            if (filename === path.join(this.pagesDir, `api.${extension}`)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async transform(files) {
+        const matchers = [];
+        for (const filename of files){
+            // If the file isn't a match for this matcher, then skip it.
+            if (!this.test(filename)) continue;
+            const pathname = this.normalizers.pathname.normalize(filename);
+            const page = this.normalizers.page.normalize(filename);
+            const bundlePath = this.normalizers.bundlePath.normalize(filename);
+            if (this.localeNormalizer) {
+                matchers.push(new PagesLocaleRouteMatcher({
+                    kind: RouteKind.PAGES,
+                    pathname,
+                    page,
+                    bundlePath,
+                    filename,
+                    i18n: {}
+                }));
+            } else {
+                matchers.push(new PagesRouteMatcher({
+                    kind: RouteKind.PAGES,
+                    pathname,
+                    page,
+                    bundlePath,
+                    filename
+                }));
+            }
+        }
+        return matchers;
+    }
+}
+
+//# sourceMappingURL=dev-pages-route-matcher-provider.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/file-cache-route-matcher-provider.js

@@ -0,0 +1,20 @@
+import { CachedRouteMatcherProvider } from '../helpers/cached-route-matcher-provider';
+/**
+ * This will memoize the matchers when the file contents are the same.
+ */ export class FileCacheRouteMatcherProvider extends CachedRouteMatcherProvider {
+    constructor(dir, reader){
+        super({
+            load: async ()=>reader.read(dir),
+            compare: (left, right)=>{
+                if (left.length !== right.length) return false;
+                // Assuming the file traversal order is deterministic...
+                for(let i = 0; i < left.length; i++){
+                    if (left[i] !== right[i]) return false;
+                }
+                return true;
+            }
+        });
+    }
+}
+
+//# sourceMappingURL=file-cache-route-matcher-provider.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/file-cache-route-matcher-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-matcher-providers/dev/file-cache-route-matcher-provider.ts"],"sourcesContent":["import type { RouteMatcher } from '../../route-matchers/route-matcher'\nimport { CachedRouteMatcherProvider } from '../helpers/cached-route-matcher-provider'\nimport type { FileReader } from './helpers/file-reader/file-reader'\n\n/**\n * This will memoize the matchers when the file contents are the same.\n */\nexport abstract class FileCacheRouteMatcherProvider<\n  M extends RouteMatcher = RouteMatcher,\n> extends CachedRouteMatcherProvider<M, ReadonlyArray<string>> {\n  constructor(dir: string, reader: FileReader) {\n    super({\n      load: async () => reader.read(dir),\n      compare: (left, right) => {\n        if (left.length !== right.length) return false\n\n        // Assuming the file traversal order is deterministic...\n        for (let i = 0; i < left.length; i++) {\n          if (left[i] !== right[i]) return false\n        }\n\n        return true\n      },\n    })\n  }\n}\n"],"names":["CachedRouteMatcherProvider","FileCacheRouteMatcherProvider","constructor","dir","reader","load","read","compare","left","right","length","i"],"mappings":"AACA,SAASA,0BAA0B,QAAQ,2CAA0C;AAGrF;;CAEC,GACD,OAAO,MAAeC,sCAEZD;IACRE,YAAYC,GAAW,EAAEC,MAAkB,CAAE;QAC3C,KAAK,CAAC;YACJC,MAAM,UAAYD,OAAOE,IAAI,CAACH;YAC9BI,SAAS,CAACC,MAAMC;gBACd,IAAID,KAAKE,MAAM,KAAKD,MAAMC,MAAM,EAAE,OAAO;gBAEzC,wDAAwD;gBACxD,IAAK,IAAIC,IAAI,GAAGA,IAAIH,KAAKE,MAAM,EAAEC,IAAK;oBACpC,IAAIH,IAAI,CAACG,EAAE,KAAKF,KAAK,CAACE,EAAE,EAAE,OAAO;gBACnC;gBAEA,OAAO;YACT;QACF;IACF;AACF","ignoreList":[0]}

node_modules/next/dist/esm/server/route-matcher-providers/dev/helpers/file-reader/batched-file-reader.js

@@ -0,0 +1,99 @@
+/**
+ * CachedFileReader will deduplicate requests made to the same folder structure
+ * to scan for files.
+ */ export class BatchedFileReader {
+    constructor(reader){
+        this.reader = reader;
+    }
+    schedule(callback) {
+        if (!this.schedulePromise) {
+            this.schedulePromise = Promise.resolve();
+        }
+        this.schedulePromise.then(()=>{
+            process.nextTick(callback);
+        });
+    }
+    getOrCreateBatch() {
+        // If there is an existing batch and it's not completed, then reuse it.
+        if (this.batch && !this.batch.completed) {
+            return this.batch;
+        }
+        const batch = {
+            completed: false,
+            directories: [],
+            callbacks: []
+        };
+        this.batch = batch;
+        this.schedule(async ()=>{
+            batch.completed = true;
+            if (batch.directories.length === 0) return;
+            // Collect all the results for each of the directories. If any error
+            // occurs, send the results back to the loaders.
+            let values;
+            try {
+                values = await this.load(batch.directories);
+            } catch (err) {
+                // Reject all the callbacks.
+                for (const { reject } of batch.callbacks){
+                    reject(err);
+                }
+                return;
+            }
+            // Loop over all the callbacks and send them their results.
+            for(let i = 0; i < batch.callbacks.length; i++){
+                const value = values[i];
+                if (value instanceof Error) {
+                    batch.callbacks[i].reject(value);
+                } else {
+                    batch.callbacks[i].resolve(value);
+                }
+            }
+        });
+        return batch;
+    }
+    async load(directories) {
+        // Make a unique array of directories. This is what lets us de-duplicate
+        // loads for the same directory.
+        const unique = [
+            ...new Set(directories)
+        ];
+        const results = await Promise.all(unique.map(async (directory)=>{
+            let files;
+            let error;
+            try {
+                files = await this.reader.read(directory);
+            } catch (err) {
+                if (err instanceof Error) error = err;
+            }
+            return {
+                directory,
+                files,
+                error
+            };
+        }));
+        return directories.map((directory)=>{
+            const found = results.find((result)=>result.directory === directory);
+            if (!found) return [];
+            if (found.files) return found.files;
+            if (found.error) return found.error;
+            return [];
+        });
+    }
+    async read(dir) {
+        // Get or create a new file reading batch.
+        const batch = this.getOrCreateBatch();
+        // Push this directory into the batch to resolve.
+        batch.directories.push(dir);
+        // Push the promise handles into the batch (under the same index) so it can
+        // be resolved later when it's scheduled.
+        const promise = new Promise((resolve, reject)=>{
+            batch.callbacks.push({
+                resolve,
+                reject
+            });
+        });
+        return promise;
+    }
+}
+
+//# sourceMappingURL=batched-file-reader.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/helpers/file-reader/default-file-reader.js

@@ -0,0 +1,35 @@
+import { recursiveReadDir } from '../../../../../lib/recursive-readdir';
+/**
+ * Reads all the files in the directory and its subdirectories following any
+ * symbolic links.
+ */ export class DefaultFileReader {
+    /**
+   * Creates a new file reader.
+   *
+   * @param pathnameFilter filter to ignore files with absolute pathnames, false to ignore
+   * @param ignoreFilter filter to ignore files and directories with absolute pathnames, false to ignore
+   * @param ignorePartFilter filter to ignore files and directories with the pathname part, false to ignore
+   */ constructor(options){
+        this.options = options;
+    }
+    /**
+   * Reads all the files in the directory and its subdirectories following any
+   * symbolic links.
+   *
+   * @param dir the directory to read
+   * @returns a promise that resolves to the list of files
+   */ async read(dir) {
+        return recursiveReadDir(dir, {
+            pathnameFilter: this.options.pathnameFilter,
+            ignorePartFilter: this.options.ignorePartFilter,
+            // We don't need to sort the results because we're not depending on the
+            // order of the results.
+            sortPathnames: false,
+            // We want absolute pathnames because we're going to be comparing them
+            // with other absolute pathnames.
+            relativePathnames: false
+        });
+    }
+}
+
+//# sourceMappingURL=default-file-reader.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/helpers/file-reader/default-file-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-matcher-providers/dev/helpers/file-reader/default-file-reader.ts"],"sourcesContent":["import type { FileReader } from './file-reader'\nimport type { RecursiveReadDirOptions } from '../../../../../lib/recursive-readdir'\nimport { recursiveReadDir } from '../../../../../lib/recursive-readdir'\n\nexport type DefaultFileReaderOptions = Pick<\n  RecursiveReadDirOptions,\n  'pathnameFilter' | 'ignorePartFilter'\n>\n\n/**\n * Reads all the files in the directory and its subdirectories following any\n * symbolic links.\n */\nexport class DefaultFileReader implements FileReader {\n  /**\n   * Filter to ignore files with absolute pathnames. If undefined, no files are\n   * ignored.\n   */\n  private readonly options: Readonly<DefaultFileReaderOptions>\n\n  /**\n   * Creates a new file reader.\n   *\n   * @param pathnameFilter filter to ignore files with absolute pathnames, false to ignore\n   * @param ignoreFilter filter to ignore files and directories with absolute pathnames, false to ignore\n   * @param ignorePartFilter filter to ignore files and directories with the pathname part, false to ignore\n   */\n  constructor(options: Readonly<DefaultFileReaderOptions>) {\n    this.options = options\n  }\n\n  /**\n   * Reads all the files in the directory and its subdirectories following any\n   * symbolic links.\n   *\n   * @param dir the directory to read\n   * @returns a promise that resolves to the list of files\n   */\n  public async read(dir: string): Promise<ReadonlyArray<string>> {\n    return recursiveReadDir(dir, {\n      pathnameFilter: this.options.pathnameFilter,\n      ignorePartFilter: this.options.ignorePartFilter,\n\n      // We don't need to sort the results because we're not depending on the\n      // order of the results.\n      sortPathnames: false,\n\n      // We want absolute pathnames because we're going to be comparing them\n      // with other absolute pathnames.\n      relativePathnames: false,\n    })\n  }\n}\n"],"names":["recursiveReadDir","DefaultFileReader","constructor","options","read","dir","pathnameFilter","ignorePartFilter","sortPathnames","relativePathnames"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,uCAAsC;AAOvE;;;CAGC,GACD,OAAO,MAAMC;IAOX;;;;;;GAMC,GACDC,YAAYC,OAA2C,CAAE;QACvD,IAAI,CAACA,OAAO,GAAGA;IACjB;IAEA;;;;;;GAMC,GACD,MAAaC,KAAKC,GAAW,EAAkC;QAC7D,OAAOL,iBAAiBK,KAAK;YAC3BC,gBAAgB,IAAI,CAACH,OAAO,CAACG,cAAc;YAC3CC,kBAAkB,IAAI,CAACJ,OAAO,CAACI,gBAAgB;YAE/C,uEAAuE;YACvE,wBAAwB;YACxBC,eAAe;YAEf,sEAAsE;YACtE,iCAAiC;YACjCC,mBAAmB;QACrB;IACF;AACF","ignoreList":[0]}

node_modules/next/dist/esm/server/route-matcher-providers/dev/helpers/file-reader/file-reader.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=file-reader.js.map

node_modules/next/dist/esm/server/route-matcher-providers/dev/helpers/file-reader/file-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/server/route-matcher-providers/dev/helpers/file-reader/file-reader.ts"],"sourcesContent":["export interface FileReader {\n  /**\n   * Reads the directory contents recursively.\n   *\n   * @param dir directory to read recursively from\n   */\n  read(dir: string): Promise<ReadonlyArray<string>> | ReadonlyArray<string>\n}\n"],"names":[],"mappings":"AAAA,WAOC","ignoreList":[0]}