@depup/expo__cli 55.0.16-depup.0

package/build/src/utils/telemetry/index.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getTelemetry: function() {
+        return getTelemetry;
+    },
+    record: function() {
+        return record;
+    },
+    recordCommand: function() {
+        return recordCommand;
+    }
+});
+function _nodeprocess() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:process"));
+    _nodeprocess = function() {
+        return data;
+    };
+    return data;
+}
+const _events = require("./events");
+const _user = require("../../api/user/user");
+const _env = require("../env");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/** The singleton telemetry manager to use */ let telemetry = null;
+function getTelemetry() {
+    if (_env.env.EXPO_NO_TELEMETRY || _env.env.EXPO_OFFLINE) return null;
+    if (!telemetry) {
+        // Lazy load the telemetry client, only when enabled
+        const { Telemetry } = require('./Telemetry');
+        telemetry = new Telemetry();
+        // Flush any pending events on exit
+        _nodeprocess().default.once('SIGINT', ()=>telemetry == null ? void 0 : telemetry.flushOnExit());
+        _nodeprocess().default.once('SIGTERM', ()=>telemetry == null ? void 0 : telemetry.flushOnExit());
+        _nodeprocess().default.once('beforeExit', ()=>telemetry == null ? void 0 : telemetry.flushOnExit());
+        // Initialize the telemetry
+        (0, _user.getUserAsync)().then((actor)=>telemetry == null ? void 0 : telemetry.initialize({
+                userId: (actor == null ? void 0 : actor.id) ?? null
+            })).catch(()=>telemetry == null ? void 0 : telemetry.initialize({
+                userId: null
+            }));
+    }
+    return telemetry;
+}
+function record(records) {
+    var _getTelemetry;
+    return (_getTelemetry = getTelemetry()) == null ? void 0 : _getTelemetry.record(records);
+}
+function recordCommand(command) {
+    if (isLongRunningCommand(command)) {
+        var _getTelemetry;
+        (_getTelemetry = getTelemetry()) == null ? void 0 : _getTelemetry.setStrategy('instant');
+    }
+    return record((0, _events.commandEvent)(command));
+}
+/** Determine if the command is a long-running command, based on the command name */ function isLongRunningCommand(command) {
+    return command === 'start' || command.startsWith('run') || command.startsWith('export');
+}
+
+//# sourceMappingURL=index.js.map

package/build/src/utils/telemetry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/telemetry/index.ts"],"sourcesContent":["import process from 'node:process';\n\nimport type { Telemetry } from './Telemetry';\nimport { commandEvent } from './events';\nimport type { TelemetryRecord } from './types';\nimport { getUserAsync } from '../../api/user/user';\nimport { env } from '../env';\n\n/** The singleton telemetry manager to use */\nlet telemetry: Telemetry | null = null;\n\nexport function getTelemetry(): Telemetry | null {\n  if (env.EXPO_NO_TELEMETRY || env.EXPO_OFFLINE) return null;\n\n  if (!telemetry) {\n    // Lazy load the telemetry client, only when enabled\n    const { Telemetry } = require('./Telemetry') as typeof import('./Telemetry');\n    telemetry = new Telemetry();\n\n    // Flush any pending events on exit\n    process.once('SIGINT', () => telemetry?.flushOnExit());\n    process.once('SIGTERM', () => telemetry?.flushOnExit());\n    process.once('beforeExit', () => telemetry?.flushOnExit());\n\n    // Initialize the telemetry\n    getUserAsync()\n      .then((actor) => telemetry?.initialize({ userId: actor?.id ?? null }))\n      .catch(() => telemetry?.initialize({ userId: null }));\n  }\n\n  return telemetry;\n}\n\n/**\n * Record a single telemetry event, or multiple in a single batch.\n * The event does not need to be awaited, its:\n *   - Not sent when using `EXPO_NO_TELEMETRY` or `EXPO_OFFLINE`, and returns `null`\n *   - Sent immediately for long running commands, returns the `fetch` promise\n *   - Queued and sent in background, returns `undefined`\n */\nexport function record(records: TelemetryRecord | TelemetryRecord[]) {\n  return getTelemetry()?.record(records);\n}\n\n/**\n * Record a command invocation, and the name of the command.\n * This can be disabled with the $EXPO_NO_TELEMETRY environment variable.\n * We do this to determine how well deprecations are going before remove a command.\n */\nexport function recordCommand(command: string) {\n  if (isLongRunningCommand(command)) {\n    getTelemetry()?.setStrategy('instant');\n  }\n\n  return record(commandEvent(command));\n}\n\n/** Determine if the command is a long-running command, based on the command name */\nfunction isLongRunningCommand(command: string) {\n  return command === 'start' || command.startsWith('run') || command.startsWith('export');\n}\n"],"names":["getTelemetry","record","recordCommand","telemetry","env","EXPO_NO_TELEMETRY","EXPO_OFFLINE","Telemetry","require","process","once","flushOnExit","getUserAsync","then","actor","initialize","userId","id","catch","records","command","isLongRunningCommand","setStrategy","commandEvent","startsWith"],"mappings":";;;;;;;;;;;IAWgBA,YAAY;eAAZA;;IA6BAC,MAAM;eAANA;;IASAC,aAAa;eAAbA;;;;gEAjDI;;;;;;wBAGS;sBAEA;qBACT;;;;;;AAEpB,2CAA2C,GAC3C,IAAIC,YAA8B;AAE3B,SAASH;IACd,IAAII,QAAG,CAACC,iBAAiB,IAAID,QAAG,CAACE,YAAY,EAAE,OAAO;IAEtD,IAAI,CAACH,WAAW;QACd,oDAAoD;QACpD,MAAM,EAAEI,SAAS,EAAE,GAAGC,QAAQ;QAC9BL,YAAY,IAAII;QAEhB,mCAAmC;QACnCE,sBAAO,CAACC,IAAI,CAAC,UAAU,IAAMP,6BAAAA,UAAWQ,WAAW;QACnDF,sBAAO,CAACC,IAAI,CAAC,WAAW,IAAMP,6BAAAA,UAAWQ,WAAW;QACpDF,sBAAO,CAACC,IAAI,CAAC,cAAc,IAAMP,6BAAAA,UAAWQ,WAAW;QAEvD,2BAA2B;QAC3BC,IAAAA,kBAAY,IACTC,IAAI,CAAC,CAACC,QAAUX,6BAAAA,UAAWY,UAAU,CAAC;gBAAEC,QAAQF,CAAAA,yBAAAA,MAAOG,EAAE,KAAI;YAAK,IAClEC,KAAK,CAAC,IAAMf,6BAAAA,UAAWY,UAAU,CAAC;gBAAEC,QAAQ;YAAK;IACtD;IAEA,OAAOb;AACT;AASO,SAASF,OAAOkB,OAA4C;QAC1DnB;IAAP,QAAOA,gBAAAA,mCAAAA,cAAgBC,MAAM,CAACkB;AAChC;AAOO,SAASjB,cAAckB,OAAe;IAC3C,IAAIC,qBAAqBD,UAAU;YACjCpB;SAAAA,gBAAAA,mCAAAA,cAAgBsB,WAAW,CAAC;IAC9B;IAEA,OAAOrB,OAAOsB,IAAAA,oBAAY,EAACH;AAC7B;AAEA,kFAAkF,GAClF,SAASC,qBAAqBD,OAAe;IAC3C,OAAOA,YAAY,WAAWA,QAAQI,UAAU,CAAC,UAAUJ,QAAQI,UAAU,CAAC;AAChF"}

package/build/src/utils/telemetry/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

package/build/src/utils/telemetry/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/build/src/utils/telemetry/utils/constants.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TELEMETRY_ENDPOINT: function() {
+        return TELEMETRY_ENDPOINT;
+    },
+    TELEMETRY_TARGET: function() {
+        return TELEMETRY_TARGET;
+    }
+});
+const _env = require("../../env");
+const TELEMETRY_ENDPOINT = 'https://cdp.expo.dev/v1/batch';
+const TELEMETRY_TARGET = _env.env.EXPO_STAGING || _env.env.EXPO_LOCAL ? '24TKICqYKilXM480mA7ktgVDdea' : '24TKR7CQAaGgIrLTgu3Fp4OdOkI'; // expo unified
+
+//# sourceMappingURL=constants.js.map

package/build/src/utils/telemetry/utils/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/utils/telemetry/utils/constants.ts"],"sourcesContent":["import { env } from '../../env';\n\nexport const TELEMETRY_ENDPOINT = 'https://cdp.expo.dev/v1/batch';\n\nexport const TELEMETRY_TARGET =\n  env.EXPO_STAGING || env.EXPO_LOCAL\n    ? '24TKICqYKilXM480mA7ktgVDdea'\n    : '24TKR7CQAaGgIrLTgu3Fp4OdOkI'; // expo unified\n"],"names":["TELEMETRY_ENDPOINT","TELEMETRY_TARGET","env","EXPO_STAGING","EXPO_LOCAL"],"mappings":";;;;;;;;;;;IAEaA,kBAAkB;eAAlBA;;IAEAC,gBAAgB;eAAhBA;;;qBAJO;AAEb,MAAMD,qBAAqB;AAE3B,MAAMC,mBACXC,QAAG,CAACC,YAAY,IAAID,QAAG,CAACE,UAAU,GAC9B,gCACA,+BAA+B,eAAe"}

package/build/src/utils/telemetry/utils/context.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createContext", {
+    enumerable: true,
+    get: function() {
+        return createContext;
+    }
+});
+function _ciinfo() {
+    const data = /*#__PURE__*/ _interop_require_wildcard(require("ci-info"));
+    _ciinfo = function() {
+        return data;
+    };
+    return data;
+}
+function _os() {
+    const data = /*#__PURE__*/ _interop_require_default(require("os"));
+    _os = function() {
+        return data;
+    };
+    return data;
+}
+const _array = require("../../array");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function createContext() {
+    return {
+        os: {
+            name: _os().default.platform(),
+            version: _os().default.release(),
+            node: process.versions.node
+        },
+        device: {
+            arch: _os().default.arch(),
+            memory: summarizeMemory()
+        },
+        cpu: summarizeCpuInfo(),
+        app: {
+            name: 'expo/cli',
+            version: "55.0.16"
+        },
+        ci: _ciinfo().isCI ? {
+            name: _ciinfo().name,
+            isPr: _ciinfo().isPR
+        } : undefined
+    };
+}
+function summarizeMemory() {
+    const gb = _os().default.totalmem() / 1024 / 1024 / 1024;
+    return Math.round(gb * 100) / 100;
+}
+function summarizeCpuInfo() {
+    const cpus = (0, _array.groupBy)(_os().default.cpus() ?? [], (item)=>item.model);
+    const summary = {
+        model: '',
+        speed: 0,
+        count: 0
+    };
+    for(const key in cpus){
+        if (cpus[key].length > summary.count) {
+            summary.model = key;
+            summary.speed = cpus[key][0].speed;
+            summary.count = cpus[key].length;
+        }
+    }
+    return !summary.model || !summary.count ? undefined : summary;
+}
+
+//# sourceMappingURL=context.js.map

package/build/src/utils/telemetry/utils/context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/utils/telemetry/utils/context.ts"],"sourcesContent":["import * as ciInfo from 'ci-info';\nimport os from 'os';\n\nimport { groupBy } from '../../array';\n\nexport function createContext() {\n  return {\n    os: { name: os.platform(), version: os.release(), node: process.versions.node },\n    device: { arch: os.arch(), memory: summarizeMemory() },\n    cpu: summarizeCpuInfo(),\n    app: { name: 'expo/cli', version: process.env.__EXPO_VERSION },\n    ci: ciInfo.isCI ? { name: ciInfo.name, isPr: ciInfo.isPR } : undefined,\n  };\n}\n\nfunction summarizeMemory() {\n  const gb = os.totalmem() / 1024 / 1024 / 1024;\n  return Math.round(gb * 100) / 100;\n}\n\nfunction summarizeCpuInfo() {\n  const cpus = groupBy(os.cpus() ?? [], (item) => item.model);\n  const summary = { model: '', speed: 0, count: 0 };\n\n  for (const key in cpus) {\n    if (cpus[key].length > summary.count) {\n      summary.model = key;\n      summary.speed = cpus[key][0].speed;\n      summary.count = cpus[key].length;\n    }\n  }\n\n  return !summary.model || !summary.count ? undefined : summary;\n}\n"],"names":["createContext","os","name","platform","version","release","node","process","versions","device","arch","memory","summarizeMemory","cpu","summarizeCpuInfo","app","env","__EXPO_VERSION","ci","ciInfo","isCI","isPr","isPR","undefined","gb","totalmem","Math","round","cpus","groupBy","item","model","summary","speed","count","key","length"],"mappings":";;;;+BAKgBA;;;eAAAA;;;;iEALQ;;;;;;;gEACT;;;;;;uBAES;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjB,SAASA;IACd,OAAO;QACLC,IAAI;YAAEC,MAAMD,aAAE,CAACE,QAAQ;YAAIC,SAASH,aAAE,CAACI,OAAO;YAAIC,MAAMC,QAAQC,QAAQ,CAACF,IAAI;QAAC;QAC9EG,QAAQ;YAAEC,MAAMT,aAAE,CAACS,IAAI;YAAIC,QAAQC;QAAkB;QACrDC,KAAKC;QACLC,KAAK;YAAEb,MAAM;YAAYE,SAASG,QAAQS,GAAG,CAACC,cAAc;QAAC;QAC7DC,IAAIC,UAAOC,IAAI,GAAG;YAAElB,MAAMiB,UAAOjB,IAAI;YAAEmB,MAAMF,UAAOG,IAAI;QAAC,IAAIC;IAC/D;AACF;AAEA,SAASX;IACP,MAAMY,KAAKvB,aAAE,CAACwB,QAAQ,KAAK,OAAO,OAAO;IACzC,OAAOC,KAAKC,KAAK,CAACH,KAAK,OAAO;AAChC;AAEA,SAASV;IACP,MAAMc,OAAOC,IAAAA,cAAO,EAAC5B,aAAE,CAAC2B,IAAI,MAAM,EAAE,EAAE,CAACE,OAASA,KAAKC,KAAK;IAC1D,MAAMC,UAAU;QAAED,OAAO;QAAIE,OAAO;QAAGC,OAAO;IAAE;IAEhD,IAAK,MAAMC,OAAOP,KAAM;QACtB,IAAIA,IAAI,CAACO,IAAI,CAACC,MAAM,GAAGJ,QAAQE,KAAK,EAAE;YACpCF,QAAQD,KAAK,GAAGI;YAChBH,QAAQC,KAAK,GAAGL,IAAI,CAACO,IAAI,CAAC,EAAE,CAACF,KAAK;YAClCD,QAAQE,KAAK,GAAGN,IAAI,CAACO,IAAI,CAACC,MAAM;QAClC;IACF;IAEA,OAAO,CAACJ,QAAQD,KAAK,IAAI,CAACC,QAAQE,KAAK,GAAGX,YAAYS;AACxD"}

package/build/src/utils/template.js

@@ -0,0 +1,48 @@
+/**
+ * Simple unsafe interpolation for template strings. Does NOT escape values.
+ *
+ * Arguments can be named or numeric.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#tagged_templates
+ *
+ * @example
+ * const t1Closure = unsafeTemplate`${0}${1}${0}!`;
+ * // const t1Closure = unsafeTemplate(["","","","!"],0,1,0);
+ * t1Closure("Y", "A"); // "YAY!"
+ *
+ * @example
+ * const t2Closure = unsafeTemplate`${0} ${"foo"}!`;
+ * // const t2Closure = unsafeTemplate([""," ","!"],0,"foo");
+ * t2Closure("Hello", { foo: "World" }); // "Hello World!"
+ *
+ * @example
+ * const t3Closure = unsafeTemplate`I'm ${"name"}. I'm almost ${"age"} years old.`;
+ * // const t3Closure = unsafeTemplate(["I'm ", ". I'm almost ", " years old."], "name", "age");
+ * t3Closure("foo", { name: "MDN", age: 30 }); // "I'm MDN. I'm almost 30 years old."
+ * t3Closure({ name: "MDN", age: 30 }); // "I'm MDN. I'm almost 30 years old."
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unsafeTemplate", {
+    enumerable: true,
+    get: function() {
+        return unsafeTemplate;
+    }
+});
+function unsafeTemplate(strings, ...keys) {
+    return (...values)=>{
+        const lastValue = values[values.length - 1];
+        const dict = typeof lastValue === 'object' ? lastValue : {};
+        const result = [
+            strings[0]
+        ];
+        keys.forEach((key, i)=>{
+            const value = typeof key === 'number' && Number.isInteger(key) ? values[key] : dict[key];
+            result.push(value, strings[i + 1]);
+        });
+        return result.join('');
+    };
+}
+
+//# sourceMappingURL=template.js.map

package/build/src/utils/template.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/template.ts"],"sourcesContent":["/**\n * Simple unsafe interpolation for template strings. Does NOT escape values.\n *\n * Arguments can be named or numeric.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#tagged_templates\n *\n * @example\n * const t1Closure = unsafeTemplate`${0}${1}${0}!`;\n * // const t1Closure = unsafeTemplate([\"\",\"\",\"\",\"!\"],0,1,0);\n * t1Closure(\"Y\", \"A\"); // \"YAY!\"\n *\n * @example\n * const t2Closure = unsafeTemplate`${0} ${\"foo\"}!`;\n * // const t2Closure = unsafeTemplate([\"\",\" \",\"!\"],0,\"foo\");\n * t2Closure(\"Hello\", { foo: \"World\" }); // \"Hello World!\"\n *\n * @example\n * const t3Closure = unsafeTemplate`I'm ${\"name\"}. I'm almost ${\"age\"} years old.`;\n * // const t3Closure = unsafeTemplate([\"I'm \", \". I'm almost \", \" years old.\"], \"name\", \"age\");\n * t3Closure(\"foo\", { name: \"MDN\", age: 30 }); // \"I'm MDN. I'm almost 30 years old.\"\n * t3Closure({ name: \"MDN\", age: 30 }); // \"I'm MDN. I'm almost 30 years old.\"\n */\nexport function unsafeTemplate(strings: TemplateStringsArray, ...keys: (string | number)[]) {\n  return (\n    ...values: (string | number)[] | [...(string | number)[], Record<string | number, string>]\n  ) => {\n    const lastValue = values[values.length - 1];\n    const dict = typeof lastValue === 'object' ? lastValue : {};\n    const result = [strings[0]];\n    keys.forEach((key, i) => {\n      const value = typeof key === 'number' && Number.isInteger(key) ? values[key] : dict[key];\n      result.push(value as string, strings[i + 1]);\n    });\n    return result.join('');\n  };\n}\n"],"names":["unsafeTemplate","strings","keys","values","lastValue","length","dict","result","forEach","key","i","value","Number","isInteger","push","join"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,eAAeC,OAA6B,EAAE,GAAGC,IAAyB;IACxF,OAAO,CACL,GAAGC;QAEH,MAAMC,YAAYD,MAAM,CAACA,OAAOE,MAAM,GAAG,EAAE;QAC3C,MAAMC,OAAO,OAAOF,cAAc,WAAWA,YAAY,CAAC;QAC1D,MAAMG,SAAS;YAACN,OAAO,CAAC,EAAE;SAAC;QAC3BC,KAAKM,OAAO,CAAC,CAACC,KAAKC;YACjB,MAAMC,QAAQ,OAAOF,QAAQ,YAAYG,OAAOC,SAAS,CAACJ,OAAON,MAAM,CAACM,IAAI,GAAGH,IAAI,CAACG,IAAI;YACxFF,OAAOO,IAAI,CAACH,OAAiBV,OAAO,CAACS,IAAI,EAAE;QAC7C;QACA,OAAOH,OAAOQ,IAAI,CAAC;IACrB;AACF"}

package/build/src/utils/terminal.js

@@ -0,0 +1,15 @@
+/** @returns the environment variable indicating the default terminal program to use. */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getUserTerminal", {
+    enumerable: true,
+    get: function() {
+        return getUserTerminal;
+    }
+});
+function getUserTerminal() {
+    return process.env.REACT_TERMINAL || (process.platform === 'darwin' ? process.env.TERM_PROGRAM : process.env.TERM);
+}
+
+//# sourceMappingURL=terminal.js.map

package/build/src/utils/terminal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/terminal.ts"],"sourcesContent":["/** @returns the environment variable indicating the default terminal program to use. */\nexport function getUserTerminal(): string | undefined {\n  return (\n    process.env.REACT_TERMINAL ||\n    (process.platform === 'darwin' ? process.env.TERM_PROGRAM : process.env.TERM)\n  );\n}\n"],"names":["getUserTerminal","process","env","REACT_TERMINAL","platform","TERM_PROGRAM","TERM"],"mappings":"AAAA,sFAAsF;;;;+BACtEA;;;eAAAA;;;AAAT,SAASA;IACd,OACEC,QAAQC,GAAG,CAACC,cAAc,IACzBF,CAAAA,QAAQG,QAAQ,KAAK,WAAWH,QAAQC,GAAG,CAACG,YAAY,GAAGJ,QAAQC,GAAG,CAACI,IAAI,AAAD;AAE/E"}

package/build/src/utils/tsconfig/evaluateTsConfig.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    evaluateTsConfig: function() {
+        return evaluateTsConfig;
+    },
+    importTypeScriptFromProjectOptionally: function() {
+        return importTypeScriptFromProjectOptionally;
+    }
+});
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _resolvefrom() {
+    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
+    _resolvefrom = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function evaluateTsConfig(ts, tsConfigPath) {
+    const formatDiagnosticsHost = {
+        getNewLine: ()=>require('os').EOL,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getCanonicalFileName: (fileName)=>fileName
+    };
+    try {
+        var _jsonFileContents_errors;
+        const { config, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+        if (error) {
+            throw new Error(ts.formatDiagnostic(error, formatDiagnosticsHost));
+        }
+        const jsonFileContents = ts.parseJsonConfigFileContent(config, {
+            ...ts.sys,
+            readDirectory: (_, ext)=>[
+                    ext ? `file${ext[0]}` : `file.ts`
+                ]
+        }, _path().default.dirname(tsConfigPath));
+        if (jsonFileContents.errors) {
+            jsonFileContents.errors = jsonFileContents.errors.filter(({ code })=>{
+                // TS18003: filter out "no inputs were found in config file" error */
+                // TS6046: filter out "Argument for '--module' option must be" error
+                //         this error can be ignored since we're only typically interested in `paths` and `baseUrl`
+                return code !== 18003 && code !== 6046;
+            })// filter out non-error diagnostics
+            .filter(({ category })=>category !== 1 /*DiagnosticCategory.Error = 1*/ );
+        }
+        if ((_jsonFileContents_errors = jsonFileContents.errors) == null ? void 0 : _jsonFileContents_errors.length) {
+            throw new Error(ts.formatDiagnostic(jsonFileContents.errors[0], formatDiagnosticsHost));
+        }
+        return {
+            compilerOptions: jsonFileContents.options,
+            raw: config.raw
+        };
+    } catch (error) {
+        if ((error == null ? void 0 : error.name) === 'SyntaxError') {
+            throw new Error('tsconfig.json is invalid:\n' + (error.message ?? ''));
+        }
+        throw error;
+    }
+}
+function importTypeScriptFromProjectOptionally(projectRoot) {
+    const resolvedPath = _resolvefrom().default.silent(projectRoot, 'typescript');
+    if (!resolvedPath) {
+        return null;
+    }
+    return require(resolvedPath);
+}
+
+//# sourceMappingURL=evaluateTsConfig.js.map

package/build/src/utils/tsconfig/evaluateTsConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/tsconfig/evaluateTsConfig.ts"],"sourcesContent":["import path from 'path';\nimport resolveFrom from 'resolve-from';\n\nexport function evaluateTsConfig(ts: typeof import('typescript'), tsConfigPath: string) {\n  const formatDiagnosticsHost: import('typescript').FormatDiagnosticsHost = {\n    getNewLine: () => require('os').EOL,\n    getCurrentDirectory: ts.sys.getCurrentDirectory,\n    getCanonicalFileName: (fileName: string) => fileName,\n  };\n\n  try {\n    const { config, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);\n\n    if (error) {\n      throw new Error(ts.formatDiagnostic(error, formatDiagnosticsHost));\n    }\n\n    const jsonFileContents = ts.parseJsonConfigFileContent(\n      config,\n      {\n        ...ts.sys,\n        readDirectory: (_, ext) => [ext ? `file${ext[0]}` : `file.ts`],\n      },\n      path.dirname(tsConfigPath)\n    );\n\n    if (jsonFileContents.errors) {\n      jsonFileContents.errors = jsonFileContents.errors\n        .filter(({ code }) => {\n          // TS18003: filter out \"no inputs were found in config file\" error */\n          // TS6046: filter out \"Argument for '--module' option must be\" error\n          //         this error can be ignored since we're only typically interested in `paths` and `baseUrl`\n          return code !== 18003 && code !== 6046;\n        })\n        // filter out non-error diagnostics\n        .filter(({ category }) => category !== 1 /*DiagnosticCategory.Error = 1*/);\n    }\n\n    if (jsonFileContents.errors?.length) {\n      throw new Error(ts.formatDiagnostic(jsonFileContents.errors[0], formatDiagnosticsHost));\n    }\n\n    return { compilerOptions: jsonFileContents.options, raw: config.raw };\n  } catch (error: any) {\n    if (error?.name === 'SyntaxError') {\n      throw new Error('tsconfig.json is invalid:\\n' + (error.message ?? ''));\n    }\n    throw error;\n  }\n}\n\nexport function importTypeScriptFromProjectOptionally(\n  projectRoot: string\n): typeof import('typescript') | null {\n  const resolvedPath = resolveFrom.silent(projectRoot, 'typescript');\n  if (!resolvedPath) {\n    return null;\n  }\n  return require(resolvedPath);\n}\n"],"names":["evaluateTsConfig","importTypeScriptFromProjectOptionally","ts","tsConfigPath","formatDiagnosticsHost","getNewLine","require","EOL","getCurrentDirectory","sys","getCanonicalFileName","fileName","jsonFileContents","config","error","readConfigFile","readFile","Error","formatDiagnostic","parseJsonConfigFileContent","readDirectory","_","ext","path","dirname","errors","filter","code","category","length","compilerOptions","options","raw","name","message","projectRoot","resolvedPath","resolveFrom","silent"],"mappings":";;;;;;;;;;;IAGgBA,gBAAgB;eAAhBA;;IAgDAC,qCAAqC;eAArCA;;;;gEAnDC;;;;;;;gEACO;;;;;;;;;;;AAEjB,SAASD,iBAAiBE,EAA+B,EAAEC,YAAoB;IACpF,MAAMC,wBAAoE;QACxEC,YAAY,IAAMC,QAAQ,MAAMC,GAAG;QACnCC,qBAAqBN,GAAGO,GAAG,CAACD,mBAAmB;QAC/CE,sBAAsB,CAACC,WAAqBA;IAC9C;IAEA,IAAI;YA4BEC;QA3BJ,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAE,GAAGZ,GAAGa,cAAc,CAACZ,cAAcD,GAAGO,GAAG,CAACO,QAAQ;QAEzE,IAAIF,OAAO;YACT,MAAM,IAAIG,MAAMf,GAAGgB,gBAAgB,CAACJ,OAAOV;QAC7C;QAEA,MAAMQ,mBAAmBV,GAAGiB,0BAA0B,CACpDN,QACA;YACE,GAAGX,GAAGO,GAAG;YACTW,eAAe,CAACC,GAAGC,MAAQ;oBAACA,MAAM,CAAC,IAAI,EAAEA,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,OAAO,CAAC;iBAAC;QAChE,GACAC,eAAI,CAACC,OAAO,CAACrB;QAGf,IAAIS,iBAAiBa,MAAM,EAAE;YAC3Bb,iBAAiBa,MAAM,GAAGb,iBAAiBa,MAAM,CAC9CC,MAAM,CAAC,CAAC,EAAEC,IAAI,EAAE;gBACf,qEAAqE;gBACrE,oEAAoE;gBACpE,mGAAmG;gBACnG,OAAOA,SAAS,SAASA,SAAS;YACpC,EACA,mCAAmC;aAClCD,MAAM,CAAC,CAAC,EAAEE,QAAQ,EAAE,GAAKA,aAAa,EAAE,8BAA8B;QAC3E;QAEA,KAAIhB,2BAAAA,iBAAiBa,MAAM,qBAAvBb,yBAAyBiB,MAAM,EAAE;YACnC,MAAM,IAAIZ,MAAMf,GAAGgB,gBAAgB,CAACN,iBAAiBa,MAAM,CAAC,EAAE,EAAErB;QAClE;QAEA,OAAO;YAAE0B,iBAAiBlB,iBAAiBmB,OAAO;YAAEC,KAAKnB,OAAOmB,GAAG;QAAC;IACtE,EAAE,OAAOlB,OAAY;QACnB,IAAIA,CAAAA,yBAAAA,MAAOmB,IAAI,MAAK,eAAe;YACjC,MAAM,IAAIhB,MAAM,gCAAiCH,CAAAA,MAAMoB,OAAO,IAAI,EAAC;QACrE;QACA,MAAMpB;IACR;AACF;AAEO,SAASb,sCACdkC,WAAmB;IAEnB,MAAMC,eAAeC,sBAAW,CAACC,MAAM,CAACH,aAAa;IACrD,IAAI,CAACC,cAAc;QACjB,OAAO;IACT;IACA,OAAO9B,QAAQ8B;AACjB"}

package/build/src/utils/tsconfig/loadTsConfigPaths.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    loadTsConfigPathsAsync: function() {
+        return loadTsConfigPathsAsync;
+    },
+    readTsconfigAsync: function() {
+        return readTsconfigAsync;
+    }
+});
+function _jsonfile() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/json-file"));
+    _jsonfile = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _evaluateTsConfig = require("./evaluateTsConfig");
+const _dir = require("../dir");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:utils:tsconfig:load');
+async function loadTsConfigPathsAsync(dir) {
+    const options = await readTsconfigAsync(dir) ?? await readJsconfigAsync(dir);
+    if (options) {
+        var _config_compilerOptions, _config_compilerOptions1;
+        const [, config] = options;
+        return {
+            paths: (_config_compilerOptions = config.compilerOptions) == null ? void 0 : _config_compilerOptions.paths,
+            baseUrl: ((_config_compilerOptions1 = config.compilerOptions) == null ? void 0 : _config_compilerOptions1.baseUrl) ? _path().default.resolve(dir, config.compilerOptions.baseUrl) : undefined
+        };
+    }
+    return null;
+}
+async function readJsconfigAsync(projectRoot) {
+    const configPath = _path().default.join(projectRoot, 'jsconfig.json');
+    if (await (0, _dir.fileExistsAsync)(configPath)) {
+        const config = await _jsonfile().default.readAsync(configPath, {
+            json5: true
+        });
+        if (config) {
+            return [
+                configPath,
+                config
+            ];
+        }
+    }
+    return null;
+}
+async function readTsconfigAsync(projectRoot) {
+    const configPath = _path().default.join(projectRoot, 'tsconfig.json');
+    if (await (0, _dir.fileExistsAsync)(configPath)) {
+        // We need to fully evaluate the tsconfig to get the baseUrl and paths in case they were applied in `extends`.
+        const ts = (0, _evaluateTsConfig.importTypeScriptFromProjectOptionally)(projectRoot);
+        if (ts) {
+            return [
+                configPath,
+                (0, _evaluateTsConfig.evaluateTsConfig)(ts, configPath)
+            ];
+        }
+        debug(`typescript module not found in: ${projectRoot}`);
+    }
+    return null;
+}
+
+//# sourceMappingURL=loadTsConfigPaths.js.map

package/build/src/utils/tsconfig/loadTsConfigPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/tsconfig/loadTsConfigPaths.ts"],"sourcesContent":["import JsonFile from '@expo/json-file';\nimport path from 'path';\n\nimport { evaluateTsConfig, importTypeScriptFromProjectOptionally } from './evaluateTsConfig';\nimport { fileExistsAsync } from '../dir';\n\nexport type TsConfigPaths = {\n  paths?: Record<string, string[]>;\n  baseUrl?: string;\n};\n\ntype ConfigReadResults = [\n  string,\n  {\n    compilerOptions?: {\n      baseUrl?: string;\n      paths?: Record<string, string[]>;\n    };\n  },\n];\n\nconst debug = require('debug')('expo:utils:tsconfig:load') as typeof console.log;\n\nexport async function loadTsConfigPathsAsync(dir: string): Promise<TsConfigPaths | null> {\n  const options = (await readTsconfigAsync(dir)) ?? (await readJsconfigAsync(dir));\n  if (options) {\n    const [, config] = options;\n    return {\n      paths: config.compilerOptions?.paths,\n      baseUrl: config.compilerOptions?.baseUrl\n        ? path.resolve(dir, config.compilerOptions.baseUrl)\n        : undefined,\n    };\n  }\n  return null;\n}\n\nasync function readJsconfigAsync(projectRoot: string): Promise<null | ConfigReadResults> {\n  const configPath = path.join(projectRoot, 'jsconfig.json');\n  if (await fileExistsAsync(configPath)) {\n    const config = await JsonFile.readAsync(configPath, { json5: true });\n    if (config) {\n      return [configPath, config];\n    }\n  }\n  return null;\n}\n\n// TODO: Refactor for speed\nexport async function readTsconfigAsync(projectRoot: string): Promise<null | ConfigReadResults> {\n  const configPath = path.join(projectRoot, 'tsconfig.json');\n  if (await fileExistsAsync(configPath)) {\n    // We need to fully evaluate the tsconfig to get the baseUrl and paths in case they were applied in `extends`.\n    const ts = importTypeScriptFromProjectOptionally(projectRoot);\n    if (ts) {\n      return [configPath, evaluateTsConfig(ts, configPath)];\n    }\n    debug(`typescript module not found in: ${projectRoot}`);\n  }\n  return null;\n}\n"],"names":["loadTsConfigPathsAsync","readTsconfigAsync","debug","require","dir","options","readJsconfigAsync","config","paths","compilerOptions","baseUrl","path","resolve","undefined","projectRoot","configPath","join","fileExistsAsync","JsonFile","readAsync","json5","ts","importTypeScriptFromProjectOptionally","evaluateTsConfig"],"mappings":";;;;;;;;;;;IAuBsBA,sBAAsB;eAAtBA;;IA0BAC,iBAAiB;eAAjBA;;;;gEAjDD;;;;;;;gEACJ;;;;;;kCAEuD;qBACxC;;;;;;AAiBhC,MAAMC,QAAQC,QAAQ,SAAS;AAExB,eAAeH,uBAAuBI,GAAW;IACtD,MAAMC,UAAU,AAAC,MAAMJ,kBAAkBG,QAAU,MAAME,kBAAkBF;IAC3E,IAAIC,SAAS;YAGFE,yBACEA;QAHX,MAAM,GAAGA,OAAO,GAAGF;QACnB,OAAO;YACLG,KAAK,GAAED,0BAAAA,OAAOE,eAAe,qBAAtBF,wBAAwBC,KAAK;YACpCE,SAASH,EAAAA,2BAAAA,OAAOE,eAAe,qBAAtBF,yBAAwBG,OAAO,IACpCC,eAAI,CAACC,OAAO,CAACR,KAAKG,OAAOE,eAAe,CAACC,OAAO,IAChDG;QACN;IACF;IACA,OAAO;AACT;AAEA,eAAeP,kBAAkBQ,WAAmB;IAClD,MAAMC,aAAaJ,eAAI,CAACK,IAAI,CAACF,aAAa;IAC1C,IAAI,MAAMG,IAAAA,oBAAe,EAACF,aAAa;QACrC,MAAMR,SAAS,MAAMW,mBAAQ,CAACC,SAAS,CAACJ,YAAY;YAAEK,OAAO;QAAK;QAClE,IAAIb,QAAQ;YACV,OAAO;gBAACQ;gBAAYR;aAAO;QAC7B;IACF;IACA,OAAO;AACT;AAGO,eAAeN,kBAAkBa,WAAmB;IACzD,MAAMC,aAAaJ,eAAI,CAACK,IAAI,CAACF,aAAa;IAC1C,IAAI,MAAMG,IAAAA,oBAAe,EAACF,aAAa;QACrC,8GAA8G;QAC9G,MAAMM,KAAKC,IAAAA,uDAAqC,EAACR;QACjD,IAAIO,IAAI;YACN,OAAO;gBAACN;gBAAYQ,IAAAA,kCAAgB,EAACF,IAAIN;aAAY;QACvD;QACAb,MAAM,CAAC,gCAAgC,EAAEY,aAAa;IACxD;IACA,OAAO;AACT"}

package/build/src/utils/tsconfig/matchTsConfigPathAlias.js

@@ -0,0 +1,94 @@
+// From TypeScript: https://github.com/microsoft/TypeScript/blob/5b1897969769449217237aecbe364f823096c63e/src/compiler/core.ts
+// License: https://github.com/microsoft/TypeScript/blob/214df64/LICENSE.txt
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "matchTsConfigPathAlias", {
+    enumerable: true,
+    get: function() {
+        return matchTsConfigPathAlias;
+    }
+});
+const asterisk = 0x2a;
+function hasZeroOrOneAsteriskCharacter(str) {
+    let seenAsterisk = false;
+    for(let i = 0; i < str.length; i++){
+        if (str.charCodeAt(i) === asterisk) {
+            if (!seenAsterisk) {
+                seenAsterisk = true;
+            } else {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function tryParsePattern(pattern) {
+    // This should be verified outside of here and a proper error thrown.
+    const indexOfStar = pattern.indexOf('*');
+    return indexOfStar === -1 ? undefined : {
+        prefix: pattern.slice(0, indexOfStar),
+        suffix: pattern.slice(indexOfStar + 1)
+    };
+}
+function isPatternMatch({ prefix, suffix }, candidate) {
+    return candidate.length >= prefix.length + suffix.length && candidate.startsWith(prefix) && candidate.endsWith(suffix);
+}
+/**
+ * Return the object corresponding to the best pattern to match `candidate`.
+ *
+ * @internal
+ */ function findBestPatternMatch(values, getPattern, candidate) {
+    let matchedValue;
+    // use length of prefix as betterness criteria
+    let longestMatchPrefixLength = -1;
+    for (const v of values){
+        const pattern = getPattern(v);
+        if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
+            longestMatchPrefixLength = pattern.prefix.length;
+            matchedValue = v;
+        }
+    }
+    return matchedValue;
+}
+/**
+ * patternStrings contains both pattern strings (containing "*") and regular strings.
+ * Return an exact match if possible, or a pattern match, or undefined.
+ * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
+ */ function matchPatternOrExact(patternStrings, candidate) {
+    const patterns = [];
+    for (const patternString of patternStrings){
+        if (!hasZeroOrOneAsteriskCharacter(patternString)) continue;
+        const pattern = tryParsePattern(patternString);
+        if (pattern) {
+            patterns.push(pattern);
+        } else if (patternString === candidate) {
+            // pattern was matched as is - no need to search further
+            return patternString;
+        }
+    }
+    return findBestPatternMatch(patterns, (_)=>_, candidate);
+}
+/**
+ * Given that candidate matches pattern, returns the text matching the '*'.
+ * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
+ */ function matchedText(pattern, candidate) {
+    return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
+}
+function getStar(matchedPattern, moduleName) {
+    return typeof matchedPattern === 'string' ? undefined : matchedText(matchedPattern, moduleName);
+}
+function matchTsConfigPathAlias(pathsKeys, moduleName) {
+    // If the module name does not match any of the patterns in `paths` we hand off resolving to webpack
+    const matchedPattern = matchPatternOrExact(pathsKeys, moduleName);
+    if (!matchedPattern) {
+        return null;
+    }
+    return {
+        star: getStar(matchedPattern, moduleName),
+        text: typeof matchedPattern === 'string' ? matchedPattern : `${matchedPattern.prefix}*${matchedPattern.suffix}`
+    };
+}
+
+//# sourceMappingURL=matchTsConfigPathAlias.js.map

package/build/src/utils/tsconfig/matchTsConfigPathAlias.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/tsconfig/matchTsConfigPathAlias.ts"],"sourcesContent":["// From TypeScript: https://github.com/microsoft/TypeScript/blob/5b1897969769449217237aecbe364f823096c63e/src/compiler/core.ts\n// License: https://github.com/microsoft/TypeScript/blob/214df64/LICENSE.txt\n\nexport interface Pattern {\n  prefix: string;\n  suffix: string;\n}\n\nconst asterisk = 0x2a;\n\nfunction hasZeroOrOneAsteriskCharacter(str: string): boolean {\n  let seenAsterisk = false;\n  for (let i = 0; i < str.length; i++) {\n    if (str.charCodeAt(i) === asterisk) {\n      if (!seenAsterisk) {\n        seenAsterisk = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nfunction tryParsePattern(pattern: string): Pattern | undefined {\n  // This should be verified outside of here and a proper error thrown.\n  const indexOfStar = pattern.indexOf('*');\n  return indexOfStar === -1\n    ? undefined\n    : {\n        prefix: pattern.slice(0, indexOfStar),\n        suffix: pattern.slice(indexOfStar + 1),\n      };\n}\n\nfunction isPatternMatch({ prefix, suffix }: Pattern, candidate: string) {\n  return (\n    candidate.length >= prefix.length + suffix.length &&\n    candidate.startsWith(prefix) &&\n    candidate.endsWith(suffix)\n  );\n}\n\n/**\n * Return the object corresponding to the best pattern to match `candidate`.\n *\n * @internal\n */\nfunction findBestPatternMatch<T>(\n  values: readonly T[],\n  getPattern: (value: T) => Pattern,\n  candidate: string\n): T | undefined {\n  let matchedValue: T | undefined;\n  // use length of prefix as betterness criteria\n  let longestMatchPrefixLength = -1;\n\n  for (const v of values) {\n    const pattern = getPattern(v);\n    if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {\n      longestMatchPrefixLength = pattern.prefix.length;\n      matchedValue = v;\n    }\n  }\n\n  return matchedValue;\n}\n\n/**\n * patternStrings contains both pattern strings (containing \"*\") and regular strings.\n * Return an exact match if possible, or a pattern match, or undefined.\n * (These are verified by verifyCompilerOptions to have 0 or 1 \"*\" characters.)\n */\nfunction matchPatternOrExact(\n  patternStrings: readonly string[],\n  candidate: string\n): string | Pattern | undefined {\n  const patterns: Pattern[] = [];\n  for (const patternString of patternStrings) {\n    if (!hasZeroOrOneAsteriskCharacter(patternString)) continue;\n    const pattern = tryParsePattern(patternString);\n    if (pattern) {\n      patterns.push(pattern);\n    } else if (patternString === candidate) {\n      // pattern was matched as is - no need to search further\n      return patternString;\n    }\n  }\n\n  return findBestPatternMatch(patterns, (_) => _, candidate);\n}\n\n/**\n * Given that candidate matches pattern, returns the text matching the '*'.\n * E.g.: matchedText(tryParsePattern(\"foo*baz\"), \"foobarbaz\") === \"bar\"\n */\nfunction matchedText(pattern: Pattern, candidate: string): string {\n  return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);\n}\n\nfunction getStar(matchedPattern: string | Pattern, moduleName: string) {\n  return typeof matchedPattern === 'string' ? undefined : matchedText(matchedPattern, moduleName);\n}\n\nexport function matchTsConfigPathAlias(pathsKeys: string[], moduleName: string) {\n  // If the module name does not match any of the patterns in `paths` we hand off resolving to webpack\n  const matchedPattern = matchPatternOrExact(pathsKeys, moduleName);\n  if (!matchedPattern) {\n    return null;\n  }\n\n  return {\n    star: getStar(matchedPattern, moduleName),\n    text:\n      typeof matchedPattern === 'string'\n        ? matchedPattern\n        : `${matchedPattern.prefix}*${matchedPattern.suffix}`,\n  };\n}\n"],"names":["matchTsConfigPathAlias","asterisk","hasZeroOrOneAsteriskCharacter","str","seenAsterisk","i","length","charCodeAt","tryParsePattern","pattern","indexOfStar","indexOf","undefined","prefix","slice","suffix","isPatternMatch","candidate","startsWith","endsWith","findBestPatternMatch","values","getPattern","matchedValue","longestMatchPrefixLength","v","matchPatternOrExact","patternStrings","patterns","patternString","push","_","matchedText","substring","getStar","matchedPattern","moduleName","pathsKeys","star","text"],"mappings":"AAAA,8HAA8H;AAC9H,4EAA4E;;;;;+BAuG5DA;;;eAAAA;;;AAhGhB,MAAMC,WAAW;AAEjB,SAASC,8BAA8BC,GAAW;IAChD,IAAIC,eAAe;IACnB,IAAK,IAAIC,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnC,IAAIF,IAAII,UAAU,CAACF,OAAOJ,UAAU;YAClC,IAAI,CAACG,cAAc;gBACjBA,eAAe;YACjB,OAAO;gBACL,OAAO;YACT;QACF;IACF;IACA,OAAO;AACT;AAEA,SAASI,gBAAgBC,OAAe;IACtC,qEAAqE;IACrE,MAAMC,cAAcD,QAAQE,OAAO,CAAC;IACpC,OAAOD,gBAAgB,CAAC,IACpBE,YACA;QACEC,QAAQJ,QAAQK,KAAK,CAAC,GAAGJ;QACzBK,QAAQN,QAAQK,KAAK,CAACJ,cAAc;IACtC;AACN;AAEA,SAASM,eAAe,EAAEH,MAAM,EAAEE,MAAM,EAAW,EAAEE,SAAiB;IACpE,OACEA,UAAUX,MAAM,IAAIO,OAAOP,MAAM,GAAGS,OAAOT,MAAM,IACjDW,UAAUC,UAAU,CAACL,WACrBI,UAAUE,QAAQ,CAACJ;AAEvB;AAEA;;;;CAIC,GACD,SAASK,qBACPC,MAAoB,EACpBC,UAAiC,EACjCL,SAAiB;IAEjB,IAAIM;IACJ,8CAA8C;IAC9C,IAAIC,2BAA2B,CAAC;IAEhC,KAAK,MAAMC,KAAKJ,OAAQ;QACtB,MAAMZ,UAAUa,WAAWG;QAC3B,IAAIT,eAAeP,SAASQ,cAAcR,QAAQI,MAAM,CAACP,MAAM,GAAGkB,0BAA0B;YAC1FA,2BAA2Bf,QAAQI,MAAM,CAACP,MAAM;YAChDiB,eAAeE;QACjB;IACF;IAEA,OAAOF;AACT;AAEA;;;;CAIC,GACD,SAASG,oBACPC,cAAiC,EACjCV,SAAiB;IAEjB,MAAMW,WAAsB,EAAE;IAC9B,KAAK,MAAMC,iBAAiBF,eAAgB;QAC1C,IAAI,CAACzB,8BAA8B2B,gBAAgB;QACnD,MAAMpB,UAAUD,gBAAgBqB;QAChC,IAAIpB,SAAS;YACXmB,SAASE,IAAI,CAACrB;QAChB,OAAO,IAAIoB,kBAAkBZ,WAAW;YACtC,wDAAwD;YACxD,OAAOY;QACT;IACF;IAEA,OAAOT,qBAAqBQ,UAAU,CAACG,IAAMA,GAAGd;AAClD;AAEA;;;CAGC,GACD,SAASe,YAAYvB,OAAgB,EAAEQ,SAAiB;IACtD,OAAOA,UAAUgB,SAAS,CAACxB,QAAQI,MAAM,CAACP,MAAM,EAAEW,UAAUX,MAAM,GAAGG,QAAQM,MAAM,CAACT,MAAM;AAC5F;AAEA,SAAS4B,QAAQC,cAAgC,EAAEC,UAAkB;IACnE,OAAO,OAAOD,mBAAmB,WAAWvB,YAAYoB,YAAYG,gBAAgBC;AACtF;AAEO,SAASpC,uBAAuBqC,SAAmB,EAAED,UAAkB;IAC5E,oGAAoG;IACpG,MAAMD,iBAAiBT,oBAAoBW,WAAWD;IACtD,IAAI,CAACD,gBAAgB;QACnB,OAAO;IACT;IAEA,OAAO;QACLG,MAAMJ,QAAQC,gBAAgBC;QAC9BG,MACE,OAAOJ,mBAAmB,WACtBA,iBACA,GAAGA,eAAetB,MAAM,CAAC,CAAC,EAAEsB,eAAepB,MAAM,EAAE;IAC3D;AACF"}