@depup/expo__cli 55.0.16-depup.0

package/build/src/utils/prompts.js

@@ -0,0 +1,151 @@
+"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, {
+    addInteractionListener: function() {
+        return addInteractionListener;
+    },
+    confirmAsync: function() {
+        return confirmAsync;
+    },
+    createSelectionFilter: function() {
+        return createSelectionFilter;
+    },
+    default: function() {
+        return prompt;
+    },
+    pauseInteractions: function() {
+        return pauseInteractions;
+    },
+    promptAsync: function() {
+        return promptAsync;
+    },
+    removeInteractionListener: function() {
+        return removeInteractionListener;
+    },
+    resumeInteractions: function() {
+        return resumeInteractions;
+    },
+    selectAsync: function() {
+        return selectAsync;
+    }
+});
+function _assert() {
+    const data = /*#__PURE__*/ _interop_require_default(require("assert"));
+    _assert = function() {
+        return data;
+    };
+    return data;
+}
+function _prompts() {
+    const data = /*#__PURE__*/ _interop_require_default(require("prompts"));
+    _prompts = function() {
+        return data;
+    };
+    return data;
+}
+const _errors = require("./errors");
+const _interactive = require("./interactive");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:utils:prompts');
+/** Interaction observers for detecting when keystroke tracking should pause/resume. */ const listeners = [];
+async function prompt(questions, { nonInteractiveHelp, ...options } = {}) {
+    questions = Array.isArray(questions) ? questions : [
+        questions
+    ];
+    if (!(0, _interactive.isInteractive)() && questions.length !== 0) {
+        let message = `Input is required, but 'npx expo' is in non-interactive mode.\n`;
+        if (nonInteractiveHelp) {
+            message += nonInteractiveHelp;
+        } else {
+            const question = questions[0];
+            const questionMessage = typeof question.message === 'function' ? question.message(undefined, {}, question) : question.message;
+            message += `Required input:\n${(questionMessage || '').trim().replace(/^/gm, '> ')}`;
+        }
+        throw new _errors.CommandError('NON_INTERACTIVE', message);
+    }
+    pauseInteractions();
+    try {
+        const results = await (0, _prompts().default)(questions, {
+            onCancel () {
+                throw new _errors.AbortCommandError();
+            },
+            ...options
+        });
+        return results;
+    } finally{
+        resumeInteractions();
+    }
+}
+async function confirmAsync(questions, options) {
+    const { value } = await prompt({
+        initial: true,
+        ...questions,
+        name: 'value',
+        type: 'confirm'
+    }, options);
+    return value ?? null;
+}
+async function selectAsync(message, choices, options) {
+    const { value } = await prompt({
+        message,
+        choices,
+        name: 'value',
+        type: 'select'
+    }, options);
+    return value ?? null;
+}
+const promptAsync = prompt;
+function addInteractionListener(callback) {
+    listeners.push(callback);
+}
+function removeInteractionListener(callback) {
+    const listenerIndex = listeners.findIndex((_callback)=>_callback === callback);
+    (0, _assert().default)(listenerIndex >= 0, 'removeInteractionListener(): cannot remove an unregistered event listener.');
+    listeners.splice(listenerIndex, 1);
+}
+function pauseInteractions(options = {}) {
+    debug('Interaction observers paused');
+    for (const listener of listeners){
+        listener({
+            pause: true,
+            ...options
+        });
+    }
+}
+function resumeInteractions(options = {}) {
+    debug('Interaction observers resumed');
+    for (const listener of listeners){
+        listener({
+            pause: false,
+            ...options
+        });
+    }
+}
+function createSelectionFilter() {
+    function escapeRegex(string) {
+        return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+    return async (input, choices)=>{
+        try {
+            const regex = new RegExp(escapeRegex(input), 'i');
+            return choices.filter((choice)=>regex.test(choice.title));
+        } catch (error) {
+            debug('Error filtering choices', error);
+            return [];
+        }
+    };
+}
+
+//# sourceMappingURL=prompts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/prompts.ts"],"sourcesContent":["import assert from 'assert';\nimport prompts, { Choice, Options, PromptObject } from 'prompts';\n\nimport { AbortCommandError, CommandError } from './errors';\nimport { isInteractive } from './interactive';\n\nconst debug = require('debug')('expo:utils:prompts') as typeof console.log;\n\nexport type Question<V extends string = string> = PromptObject<V> & {\n  optionsPerPage?: number;\n};\n\nexport interface ExpoChoice<T> extends Choice {\n  value: T;\n}\n\ntype PromptOptions = { nonInteractiveHelp?: string } & Options;\n\nexport type NamelessQuestion = Omit<Question<'value'>, 'name' | 'type'>;\n\ntype InteractionOptions = { pause: boolean; canEscape?: boolean };\n\ntype InteractionCallback = (options: InteractionOptions) => void;\n\n/** Interaction observers for detecting when keystroke tracking should pause/resume. */\nconst listeners: InteractionCallback[] = [];\n\nexport default async function prompt(\n  questions: Question | Question[],\n  { nonInteractiveHelp, ...options }: PromptOptions = {}\n) {\n  questions = Array.isArray(questions) ? questions : [questions];\n  if (!isInteractive() && questions.length !== 0) {\n    let message = `Input is required, but 'npx expo' is in non-interactive mode.\\n`;\n    if (nonInteractiveHelp) {\n      message += nonInteractiveHelp;\n    } else {\n      const question = questions[0];\n      const questionMessage =\n        typeof question.message === 'function'\n          ? question.message(undefined, {}, question)\n          : question.message;\n\n      message += `Required input:\\n${(questionMessage || '').trim().replace(/^/gm, '> ')}`;\n    }\n    throw new CommandError('NON_INTERACTIVE', message);\n  }\n\n  pauseInteractions();\n  try {\n    const results = await prompts(questions, {\n      onCancel() {\n        throw new AbortCommandError();\n      },\n      ...options,\n    });\n\n    return results;\n  } finally {\n    resumeInteractions();\n  }\n}\n\n/**\n * Create a standard yes/no confirmation that can be cancelled.\n *\n * @param questions\n * @param options\n */\nexport async function confirmAsync(\n  questions: NamelessQuestion,\n  options?: PromptOptions\n): Promise<boolean> {\n  const { value } = await prompt(\n    {\n      initial: true,\n      ...questions,\n      name: 'value',\n      type: 'confirm',\n    },\n    options\n  );\n  return value ?? null;\n}\n\n/** Select an option from a list of options. */\nexport async function selectAsync<T>(\n  message: string,\n  choices: ExpoChoice<T>[],\n  options?: PromptOptions\n): Promise<T> {\n  const { value } = await prompt(\n    {\n      message,\n      choices,\n      name: 'value',\n      type: 'select',\n    },\n    options\n  );\n  return value ?? null;\n}\n\nexport const promptAsync = prompt;\n\n/** Used to pause/resume interaction observers while prompting (made for TerminalUI). */\nexport function addInteractionListener(callback: InteractionCallback) {\n  listeners.push(callback);\n}\n\nexport function removeInteractionListener(callback: InteractionCallback) {\n  const listenerIndex = listeners.findIndex((_callback) => _callback === callback);\n  assert(\n    listenerIndex >= 0,\n    'removeInteractionListener(): cannot remove an unregistered event listener.'\n  );\n  listeners.splice(listenerIndex, 1);\n}\n\n/** Notify all listeners that keypress observations must pause. */\nexport function pauseInteractions(options: Omit<InteractionOptions, 'pause'> = {}) {\n  debug('Interaction observers paused');\n  for (const listener of listeners) {\n    listener({ pause: true, ...options });\n  }\n}\n\n/** Notify all listeners that keypress observations can start.. */\nexport function resumeInteractions(options: Omit<InteractionOptions, 'pause'> = {}) {\n  debug('Interaction observers resumed');\n  for (const listener of listeners) {\n    listener({ pause: false, ...options });\n  }\n}\n\nexport function createSelectionFilter(): (input: any, choices: Choice[]) => Promise<any> {\n  function escapeRegex(string: string) {\n    return string.replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n  }\n\n  return async (input: any, choices: Choice[]) => {\n    try {\n      const regex = new RegExp(escapeRegex(input), 'i');\n      return choices.filter((choice: any) => regex.test(choice.title));\n    } catch (error: any) {\n      debug('Error filtering choices', error);\n      return [];\n    }\n  };\n}\n"],"names":["addInteractionListener","confirmAsync","createSelectionFilter","prompt","pauseInteractions","promptAsync","removeInteractionListener","resumeInteractions","selectAsync","debug","require","listeners","questions","nonInteractiveHelp","options","Array","isArray","isInteractive","length","message","question","questionMessage","undefined","trim","replace","CommandError","results","prompts","onCancel","AbortCommandError","value","initial","name","type","choices","callback","push","listenerIndex","findIndex","_callback","assert","splice","listener","pause","escapeRegex","string","input","regex","RegExp","filter","choice","test","title","error"],"mappings":";;;;;;;;;;;IA0GgBA,sBAAsB;eAAtBA;;IArCMC,YAAY;eAAZA;;IAkENC,qBAAqB;eAArBA;;IA5GhB,OAkCC;eAlC6BC;;IA6FdC,iBAAiB;eAAjBA;;IAjBHC,WAAW;eAAXA;;IAOGC,yBAAyB;eAAzBA;;IAkBAC,kBAAkB;eAAlBA;;IA1CMC,WAAW;eAAXA;;;;gEAtFH;;;;;;;gEACoC;;;;;;wBAEP;6BAClB;;;;;;AAE9B,MAAMC,QAAQC,QAAQ,SAAS;AAkB/B,qFAAqF,GACrF,MAAMC,YAAmC,EAAE;AAE5B,eAAeR,OAC5BS,SAAgC,EAChC,EAAEC,kBAAkB,EAAE,GAAGC,SAAwB,GAAG,CAAC,CAAC;IAEtDF,YAAYG,MAAMC,OAAO,CAACJ,aAAaA,YAAY;QAACA;KAAU;IAC9D,IAAI,CAACK,IAAAA,0BAAa,OAAML,UAAUM,MAAM,KAAK,GAAG;QAC9C,IAAIC,UAAU,CAAC,+DAA+D,CAAC;QAC/E,IAAIN,oBAAoB;YACtBM,WAAWN;QACb,OAAO;YACL,MAAMO,WAAWR,SAAS,CAAC,EAAE;YAC7B,MAAMS,kBACJ,OAAOD,SAASD,OAAO,KAAK,aACxBC,SAASD,OAAO,CAACG,WAAW,CAAC,GAAGF,YAChCA,SAASD,OAAO;YAEtBA,WAAW,CAAC,iBAAiB,EAAE,AAACE,CAAAA,mBAAmB,EAAC,EAAGE,IAAI,GAAGC,OAAO,CAAC,OAAO,OAAO;QACtF;QACA,MAAM,IAAIC,oBAAY,CAAC,mBAAmBN;IAC5C;IAEAf;IACA,IAAI;QACF,MAAMsB,UAAU,MAAMC,IAAAA,kBAAO,EAACf,WAAW;YACvCgB;gBACE,MAAM,IAAIC,yBAAiB;YAC7B;YACA,GAAGf,OAAO;QACZ;QAEA,OAAOY;IACT,SAAU;QACRnB;IACF;AACF;AAQO,eAAeN,aACpBW,SAA2B,EAC3BE,OAAuB;IAEvB,MAAM,EAAEgB,KAAK,EAAE,GAAG,MAAM3B,OACtB;QACE4B,SAAS;QACT,GAAGnB,SAAS;QACZoB,MAAM;QACNC,MAAM;IACR,GACAnB;IAEF,OAAOgB,SAAS;AAClB;AAGO,eAAetB,YACpBW,OAAe,EACfe,OAAwB,EACxBpB,OAAuB;IAEvB,MAAM,EAAEgB,KAAK,EAAE,GAAG,MAAM3B,OACtB;QACEgB;QACAe;QACAF,MAAM;QACNC,MAAM;IACR,GACAnB;IAEF,OAAOgB,SAAS;AAClB;AAEO,MAAMzB,cAAcF;AAGpB,SAASH,uBAAuBmC,QAA6B;IAClExB,UAAUyB,IAAI,CAACD;AACjB;AAEO,SAAS7B,0BAA0B6B,QAA6B;IACrE,MAAME,gBAAgB1B,UAAU2B,SAAS,CAAC,CAACC,YAAcA,cAAcJ;IACvEK,IAAAA,iBAAM,EACJH,iBAAiB,GACjB;IAEF1B,UAAU8B,MAAM,CAACJ,eAAe;AAClC;AAGO,SAASjC,kBAAkBU,UAA6C,CAAC,CAAC;IAC/EL,MAAM;IACN,KAAK,MAAMiC,YAAY/B,UAAW;QAChC+B,SAAS;YAAEC,OAAO;YAAM,GAAG7B,OAAO;QAAC;IACrC;AACF;AAGO,SAASP,mBAAmBO,UAA6C,CAAC,CAAC;IAChFL,MAAM;IACN,KAAK,MAAMiC,YAAY/B,UAAW;QAChC+B,SAAS;YAAEC,OAAO;YAAO,GAAG7B,OAAO;QAAC;IACtC;AACF;AAEO,SAASZ;IACd,SAAS0C,YAAYC,MAAc;QACjC,OAAOA,OAAOrB,OAAO,CAAC,yBAAyB;IACjD;IAEA,OAAO,OAAOsB,OAAYZ;QACxB,IAAI;YACF,MAAMa,QAAQ,IAAIC,OAAOJ,YAAYE,QAAQ;YAC7C,OAAOZ,QAAQe,MAAM,CAAC,CAACC,SAAgBH,MAAMI,IAAI,CAACD,OAAOE,KAAK;QAChE,EAAE,OAAOC,OAAY;YACnB5C,MAAM,2BAA2B4C;YACjC,OAAO,EAAE;QACX;IACF;AACF"}

package/build/src/utils/qr.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "printQRCode", {
+    enumerable: true,
+    get: function() {
+        return printQRCode;
+    }
+});
+function _nodetty() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:tty"));
+    _nodetty = function() {
+        return data;
+    };
+    return data;
+}
+function _toqr() {
+    const data = require("toqr");
+    _toqr = function() {
+        return data;
+    };
+    return data;
+}
+const _env = require("./env");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../log"));
+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 printQRCode(url) {
+    const qr = (0, _toqr().toQR)(url);
+    const output = supportsSextants() ? createSextantOutput(qr) : createHalfblockOutput(qr);
+    return {
+        lines: output.split('\n').length,
+        print () {
+            _log.log(output);
+        }
+    };
+}
+/** On specific terminals we can print a smaller QR code */ function supportsSextants() {
+    var _process_env_WT_SESSION, _process_env_KITTY_WINDOW_ID, _process_env_ALACRITTY_WINDOW_ID;
+    if (_env.env.CI || !_nodetty().default.isatty(1) || !_nodetty().default.isatty(2)) {
+        return false;
+    } else if (process.env.COLOR === '0' || process.env.COLOR === 'false') {
+        return false;
+    }
+    const isWindowsTerminal = process.platform === 'win32' && !!((_process_env_WT_SESSION = process.env.WT_SESSION) == null ? void 0 : _process_env_WT_SESSION.length);
+    const isGhostty = process.env.TERM_PROGRAM === 'ghostty';
+    const isWezterm = process.env.TERM_PROGRAM === 'WezTerm';
+    const isKitty = !!((_process_env_KITTY_WINDOW_ID = process.env.KITTY_WINDOW_ID) == null ? void 0 : _process_env_KITTY_WINDOW_ID.length);
+    const isAlacritty = !!((_process_env_ALACRITTY_WINDOW_ID = process.env.ALACRITTY_WINDOW_ID) == null ? void 0 : _process_env_ALACRITTY_WINDOW_ID.length);
+    return isWindowsTerminal || isGhostty || isWezterm || isKitty || isAlacritty;
+}
+/** ANSI QR code output by using half-blocks (1x2-sized unicode blocks) */ function createHalfblockOutput(data) {
+    const extent = Math.sqrt(data.byteLength) | 0;
+    const CHAR_00 = '\u2588';
+    const CHAR_10 = '\u2584';
+    const CHAR_01 = '\u2580';
+    const CHAR_11 = ' ';
+    let output = '';
+    output += CHAR_10.repeat(extent + 2);
+    for(let row = 0; row < extent; row += 2){
+        output += '\n' + CHAR_00;
+        for(let col = 0; col < extent; col++){
+            const value = data[row * extent + col] << 1 | data[(row + 1) * extent + col];
+            switch(value){
+                case 0:
+                    output += CHAR_00;
+                    break;
+                case 1:
+                    output += CHAR_01;
+                    break;
+                case 2:
+                    output += CHAR_10;
+                    break;
+                case 3:
+                    output += CHAR_11;
+                    break;
+            }
+        }
+        output += CHAR_00;
+    }
+    if (extent % 2 === 0) {
+        output += '\n' + CHAR_01.repeat(extent + 2);
+    }
+    output += '\n';
+    return output;
+}
+/** ANSI QR code output by using sextant-blocks (2x3-sized unicode blocks) */ function createSextantOutput(data) {
+    const getChar = (p)=>{
+        // Invert then reverse
+        let char = p ^ 63;
+        char = (char & 0xaa) >> 1 | (char & 0x55) << 1;
+        char = (char & 0xcc) >> 2 | (char & 0x33) << 2;
+        char = char >> 4 | char << 4;
+        char = char >> 2 & 63;
+        switch(char){
+            case 0:
+                return ' ';
+            case 63:
+                return '\u2588';
+            case 21:
+                return '\u258C';
+            case 42:
+                return '\u2590';
+            default:
+                return String.fromCodePoint(0x1fb00 + char - 1 - (char > 21 ? 1 : 0) - (char > 42 ? 1 : 0));
+        }
+    };
+    const extent = Math.sqrt(data.byteLength) | 0;
+    const padded = extent + 2;
+    let output = '';
+    for(let baseRow = 0; baseRow < padded; baseRow += 3){
+        if (baseRow) output += '\n';
+        for(let baseCol = 0; baseCol < padded; baseCol += 2){
+            let p = 0;
+            for(let dr = 0; dr < 3; dr++){
+                for(let dc = 0; dc < 2; dc++){
+                    const r = baseRow + dr;
+                    const c = baseCol + dc;
+                    const bit = 5 - (dr * 2 + dc);
+                    let cell = 1; // default empty (out of bounds)
+                    if (r < padded && c < padded) {
+                        if (r === 0 || c === 0 || r === padded - 1 || c === padded - 1) {
+                            cell = 0; // border is filled
+                        } else if (r <= extent && c <= extent) {
+                            cell = data[(r - 1) * extent + (c - 1)];
+                        }
+                    }
+                    p |= (cell & 1) << bit;
+                }
+            }
+            output += getChar(p);
+        }
+    }
+    if (padded % 3 === 0) {
+        // Only add newline if the padded output lines up with a newline exactly
+        output += '\n';
+    }
+    return output;
+}
+
+//# sourceMappingURL=qr.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/qr.ts"],"sourcesContent":["import tty from 'node:tty';\nimport { toQR } from 'toqr';\n\nimport { env } from './env';\nimport * as Log from '../log';\n\nexport interface QROutput {\n  lines: number;\n  print(): void;\n}\n\n/** Print the world famous 'Expo QR Code'. */\nexport function printQRCode(url: string): QROutput {\n  const qr = toQR(url);\n  const output = supportsSextants() ? createSextantOutput(qr) : createHalfblockOutput(qr);\n  return {\n    lines: output.split('\\n').length,\n    print() {\n      Log.log(output);\n    },\n  };\n}\n\n/** On specific terminals we can print a smaller QR code */\nfunction supportsSextants() {\n  if (env.CI || !tty.isatty(1) || !tty.isatty(2)) {\n    return false;\n  } else if (process.env.COLOR === '0' || process.env.COLOR === 'false') {\n    return false;\n  }\n  const isWindowsTerminal = process.platform === 'win32' && !!process.env.WT_SESSION?.length;\n  const isGhostty = process.env.TERM_PROGRAM === 'ghostty';\n  const isWezterm = process.env.TERM_PROGRAM === 'WezTerm';\n  const isKitty = !!process.env.KITTY_WINDOW_ID?.length;\n  const isAlacritty = !!process.env.ALACRITTY_WINDOW_ID?.length;\n  return isWindowsTerminal || isGhostty || isWezterm || isKitty || isAlacritty;\n}\n\n/** ANSI QR code output by using half-blocks (1x2-sized unicode blocks) */\nfunction createHalfblockOutput(data: Uint8Array): string {\n  const extent = Math.sqrt(data.byteLength) | 0;\n  const CHAR_00 = '\\u2588';\n  const CHAR_10 = '\\u2584';\n  const CHAR_01 = '\\u2580';\n  const CHAR_11 = ' ';\n  let output = '';\n  output += CHAR_10.repeat(extent + 2);\n  for (let row = 0; row < extent; row += 2) {\n    output += '\\n' + CHAR_00;\n    for (let col = 0; col < extent; col++) {\n      const value = (data[row * extent + col] << 1) | data[(row + 1) * extent + col];\n      switch (value) {\n        case 0b00:\n          output += CHAR_00;\n          break;\n        case 0b01:\n          output += CHAR_01;\n          break;\n        case 0b10:\n          output += CHAR_10;\n          break;\n        case 0b11:\n          output += CHAR_11;\n          break;\n      }\n    }\n    output += CHAR_00;\n  }\n  if (extent % 2 === 0) {\n    output += '\\n' + CHAR_01.repeat(extent + 2);\n  }\n  output += '\\n';\n  return output;\n}\n\n/** ANSI QR code output by using sextant-blocks (2x3-sized unicode blocks) */\nfunction createSextantOutput(data: Uint8Array): string {\n  const getChar = (p: number): string => {\n    // Invert then reverse\n    let char = p ^ 0b111111;\n    char = ((char & 0xaa) >> 1) | ((char & 0x55) << 1);\n    char = ((char & 0xcc) >> 2) | ((char & 0x33) << 2);\n    char = (char >> 4) | (char << 4);\n    char = (char >> 2) & 63;\n    switch (char) {\n      case 0:\n        return ' ';\n      case 63:\n        return '\\u2588';\n      case 21:\n        return '\\u258C';\n      case 42:\n        return '\\u2590';\n      default:\n        return String.fromCodePoint(0x1fb00 + char - 1 - (char > 21 ? 1 : 0) - (char > 42 ? 1 : 0));\n    }\n  };\n  const extent = Math.sqrt(data.byteLength) | 0;\n  const padded = extent + 2;\n  let output = '';\n  for (let baseRow = 0; baseRow < padded; baseRow += 3) {\n    if (baseRow) output += '\\n';\n    for (let baseCol = 0; baseCol < padded; baseCol += 2) {\n      let p = 0;\n      for (let dr = 0; dr < 3; dr++) {\n        for (let dc = 0; dc < 2; dc++) {\n          const r = baseRow + dr;\n          const c = baseCol + dc;\n          const bit = 5 - (dr * 2 + dc);\n          let cell = 1; // default empty (out of bounds)\n          if (r < padded && c < padded) {\n            if (r === 0 || c === 0 || r === padded - 1 || c === padded - 1) {\n              cell = 0; // border is filled\n            } else if (r <= extent && c <= extent) {\n              cell = data[(r - 1) * extent + (c - 1)];\n            }\n          }\n          p |= (cell & 1) << bit;\n        }\n      }\n      output += getChar(p);\n    }\n  }\n  if (padded % 3 === 0) {\n    // Only add newline if the padded output lines up with a newline exactly\n    output += '\\n';\n  }\n  return output;\n}\n"],"names":["printQRCode","url","qr","toQR","output","supportsSextants","createSextantOutput","createHalfblockOutput","lines","split","length","print","Log","log","process","env","CI","tty","isatty","COLOR","isWindowsTerminal","platform","WT_SESSION","isGhostty","TERM_PROGRAM","isWezterm","isKitty","KITTY_WINDOW_ID","isAlacritty","ALACRITTY_WINDOW_ID","data","extent","Math","sqrt","byteLength","CHAR_00","CHAR_10","CHAR_01","CHAR_11","repeat","row","col","value","getChar","p","char","String","fromCodePoint","padded","baseRow","baseCol","dr","dc","r","c","bit","cell"],"mappings":"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"}

package/build/src/utils/resolveArgs.js

@@ -0,0 +1,236 @@
+"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, {
+    _resolveStringOrBooleanArgs: function() {
+        return _resolveStringOrBooleanArgs;
+    },
+    assertDuplicateArgs: function() {
+        return assertDuplicateArgs;
+    },
+    assertNonBooleanArg: function() {
+        return assertNonBooleanArg;
+    },
+    assertUnknownArgs: function() {
+        return assertUnknownArgs;
+    },
+    collapseAliases: function() {
+        return collapseAliases;
+    },
+    resolveCustomBooleanArgsAsync: function() {
+        return resolveCustomBooleanArgsAsync;
+    },
+    resolveStringOrBooleanArgsAsync: function() {
+        return resolveStringOrBooleanArgsAsync;
+    }
+});
+const _array = require("./array");
+const _errors = require("./errors");
+/** Convert ExtraArgsSpec to arg.Spec (for validation) and extract allowedValues */ function parseExtraArgMap(extraArgMap) {
+    const spec = {};
+    const allowedValues = {};
+    for (const [key, value] of Object.entries(extraArgMap)){
+        if (typeof value === 'string') {
+            // Alias (e.g. '-f': '--flag')
+            spec[key] = value;
+        } else if (Array.isArray(value)) {
+            // Tuple [Boolean, ...strings] - Boolean is enforced by the type, but check at runtime too
+            const [first, ...stringValues] = value;
+            if (first !== Boolean) {
+                throw new _errors.CommandError('BAD_ARGS', `Invalid extraArgMap spec for ${key}: first element must be Boolean`);
+            }
+            spec[key] = Boolean;
+            allowedValues[key] = [
+                'true',
+                'false',
+                ...stringValues
+            ];
+        } else {
+            // Boolean - any value allowed
+            spec[key] = Boolean;
+        }
+    }
+    return {
+        spec,
+        allowedValues
+    };
+}
+/** Split up arguments that are formatted like `--foo=bar` or `-f="bar"` to `['--foo', 'bar']` */ function splitArgs(args) {
+    const result = [];
+    for (const arg of args){
+        if (arg.startsWith('-')) {
+            const [key, ...props] = arg.split('=');
+            result.push(key);
+            if (props.length) {
+                result.push(props.join('='));
+            }
+        } else {
+            result.push(arg);
+        }
+    }
+    return result;
+}
+async function resolveStringOrBooleanArgsAsync(argv, rawArgMap, extraArgMap) {
+    let args = splitArgs(argv);
+    const { spec: extraArgSpec, allowedValues } = parseExtraArgMap(extraArgMap);
+    const combinedSpec = {
+        ...rawArgMap,
+        ...extraArgSpec
+    };
+    // Assert any missing arguments
+    assertUnknownArgs(combinedSpec, args);
+    // Collapse aliases into fully qualified arguments.
+    args = collapseAliases(combinedSpec, args);
+    // Filter out array-type arguments so _resolveStringOrBooleanArgs can process the rest.
+    // This is necessary because _resolveStringOrBooleanArgs can't handle array-type args like --platform.
+    const filteredArgs = filterOutArrayArgs(args, combinedSpec);
+    // Resolve all of the string or boolean arguments and the project root.
+    return _resolveStringOrBooleanArgs(combinedSpec, filteredArgs, allowedValues);
+}
+async function resolveCustomBooleanArgsAsync(argv, rawArgMap, extraArgMap) {
+    const results = await resolveStringOrBooleanArgsAsync(argv, rawArgMap, extraArgMap);
+    return {
+        ...results,
+        args: Object.fromEntries(Object.entries(results.args).map(([key, value])=>{
+            // Skip aliases (e.g. '-f': '--flag') - only process actual flags
+            const extraArgValue = extraArgMap[key];
+            if (extraArgValue && typeof extraArgValue !== 'string') {
+                if (typeof value === 'string') {
+                    if (![
+                        'true',
+                        'false'
+                    ].includes(value)) {
+                        throw new _errors.CommandError('BAD_ARGS', `Invalid boolean argument: ${key}=${value}. Expected one of: true, false`);
+                    }
+                    return [
+                        key,
+                        value === 'true'
+                    ];
+                }
+            }
+            return [
+                key,
+                value
+            ];
+        }))
+    };
+}
+function _resolveStringOrBooleanArgs(arg, args, allowedValues) {
+    // Default project root, if a custom one is defined then it will overwrite this.
+    let projectRoot = '.';
+    // The resolved arguments.
+    const settings = {};
+    // Create a list of possible arguments, this will filter out aliases.
+    const possibleArgs = Object.entries(arg).filter(([, value])=>typeof value !== 'string').map(([key])=>key);
+    // Check if a value is allowed for a given flag
+    const isAllowedValue = (flag, value)=>{
+        if (!allowedValues || !allowedValues[flag]) {
+            return true; // No restrictions, allow any value
+        }
+        return allowedValues[flag].includes(value);
+    };
+    // Loop over arguments in reverse order so we can resolve if a value belongs to a flag.
+    for(let i = args.length - 1; i > -1; i--){
+        const value = args[i];
+        // At this point we should have converted all aliases to fully qualified arguments.
+        if (value.startsWith('--')) {
+            // If we ever find an argument then it must be a boolean because we are checking in reverse
+            // and removing arguments from the array if we find a string.
+            // We don't override arguments that are already set
+            if (!(value in settings)) {
+                settings[value] = true;
+            }
+        } else {
+            // Get the previous argument in the array.
+            const nextValue = i > 0 ? args[i - 1] : null;
+            if (nextValue && possibleArgs.includes(nextValue) && isAllowedValue(nextValue, value)) {
+                // We don't override arguments that are already set
+                if (!(nextValue in settings)) {
+                    settings[nextValue] = value;
+                }
+                i--;
+            } else if (// If the last value is not a flag and it doesn't have a recognized flag before it (instead having a string value or nothing)
+            // then it must be the project root.
+            i === args.length - 1) {
+                projectRoot = value;
+            } else {
+                // This will asserts if two strings are passed in a row and not at the end of the line.
+                throw new _errors.CommandError('BAD_ARGS', `Unknown argument: ${value}`);
+            }
+        }
+    }
+    return {
+        args: settings,
+        projectRoot
+    };
+}
+function collapseAliases(arg, args) {
+    const aliasMap = getAliasTuples(arg);
+    for (const [arg, alias] of aliasMap){
+        args = (0, _array.replaceAllValues)(args, arg, alias);
+    }
+    // Assert if there are duplicate flags after we collapse the aliases.
+    // Skip array-type arguments (like --platform) which can have multiple values.
+    assertDuplicateArgs(args, aliasMap, arg);
+    return args;
+}
+function assertUnknownArgs(arg, args) {
+    const allowedArgs = Object.keys(arg);
+    const unknownArgs = args.filter((arg)=>!allowedArgs.includes(arg) && arg.startsWith('-'));
+    if (unknownArgs.length > 0) {
+        throw new _errors.CommandError(`Unknown arguments: ${unknownArgs.join(', ')}`);
+    }
+}
+function getAliasTuples(arg) {
+    return Object.entries(arg).filter(([, value])=>typeof value === 'string');
+}
+/** Filter out array-type arguments from the spec (and their values).
+ * This is needed because _resolveStringOrBooleanArgs can't handle array args like --platform.
+ */ function filterOutArrayArgs(args, spec) {
+    // Get the set of flag names that are array types
+    const arrayFlags = new Set(Object.entries(spec).filter(([, value])=>Array.isArray(value)).map(([key])=>key));
+    if (arrayFlags.size === 0) {
+        return args;
+    }
+    const result = [];
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (arrayFlags.has(arg)) {
+            // Skip this flag and its value if it has one
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                i++;
+            }
+        } else {
+            result.push(arg);
+        }
+    }
+    return result;
+}
+function assertDuplicateArgs(args, argNameAliasTuple, spec) {
+    for (const [argName, argNameAlias] of argNameAliasTuple){
+        // Skip array-type arguments (like --platform) which can have multiple values
+        if (spec && Array.isArray(spec[argNameAlias])) {
+            continue;
+        }
+        if (args.filter((a)=>[
+                argName,
+                argNameAlias
+            ].includes(a)).length > 1) {
+            throw new _errors.CommandError('BAD_ARGS', `Can only provide one instance of ${argName} or ${argNameAlias}`);
+        }
+    }
+}
+function assertNonBooleanArg(argName, arg) {
+    if (arg == null || typeof arg === 'boolean') {
+        throw new _errors.CommandError('BAD_ARGS', `Expected input for arg ${argName}`);
+    }
+}
+
+//# sourceMappingURL=resolveArgs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/resolveArgs.ts"],"sourcesContent":["import arg, { Spec } from 'arg';\n\nimport { replaceAllValues } from './array';\nimport { CommandError } from './errors';\n\n/**\n * Spec for extra arguments that can be string or boolean.\n * - `'--flag': Boolean` → accepts any value\n * - `'--flag': [Boolean, 'a', 'b']` → restricted to 'true', 'false', 'a', 'b'\n * - `'-f': '--flag'` → alias\n */\nexport type ExtraArgsSpec = Record<string, typeof Boolean | string | [typeof Boolean, ...string[]]>;\n\n/** Convert ExtraArgsSpec to arg.Spec (for validation) and extract allowedValues */\nfunction parseExtraArgMap(extraArgMap: ExtraArgsSpec): {\n  spec: arg.Spec;\n  allowedValues: Record<string, string[]>;\n} {\n  const spec: arg.Spec = {};\n  const allowedValues: Record<string, string[]> = {};\n\n  for (const [key, value] of Object.entries(extraArgMap)) {\n    if (typeof value === 'string') {\n      // Alias (e.g. '-f': '--flag')\n      spec[key] = value;\n    } else if (Array.isArray(value)) {\n      // Tuple [Boolean, ...strings] - Boolean is enforced by the type, but check at runtime too\n      const [first, ...stringValues] = value;\n      if (first !== Boolean) {\n        throw new CommandError(\n          'BAD_ARGS',\n          `Invalid extraArgMap spec for ${key}: first element must be Boolean`\n        );\n      }\n      spec[key] = Boolean;\n      allowedValues[key] = ['true', 'false', ...stringValues];\n    } else {\n      // Boolean - any value allowed\n      spec[key] = Boolean;\n    }\n  }\n\n  return { spec, allowedValues };\n}\n\n/** Split up arguments that are formatted like `--foo=bar` or `-f=\"bar\"` to `['--foo', 'bar']` */\nfunction splitArgs(args: string[]): string[] {\n  const result: string[] = [];\n\n  for (const arg of args) {\n    if (arg.startsWith('-')) {\n      const [key, ...props] = arg.split('=');\n      result.push(key);\n      if (props.length) {\n        result.push(props.join('='));\n      }\n    } else {\n      result.push(arg);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Enables the resolution of arguments that can either be a string or a boolean.\n *\n * @param argv arguments that were passed to the command.\n * @param rawArgMap base argument spec defining valid arguments and their types.\n * @param extraArgMap extra arguments and aliases that should be resolved as string or boolean.\n *   - `'--flag': Boolean` → accepts any value\n *   - `'--flag': [Boolean, 'a', 'b']` → restricted to 'true', 'false', 'a', 'b'\n *   - `'-f': '--flag'` → alias\n * @returns parsed arguments and project root.\n */\nexport async function resolveStringOrBooleanArgsAsync(\n  argv: string[],\n  rawArgMap: arg.Spec,\n  extraArgMap: ExtraArgsSpec\n) {\n  let args = splitArgs(argv);\n\n  const { spec: extraArgSpec, allowedValues } = parseExtraArgMap(extraArgMap);\n  const combinedSpec = { ...rawArgMap, ...extraArgSpec };\n\n  // Assert any missing arguments\n  assertUnknownArgs(combinedSpec, args);\n\n  // Collapse aliases into fully qualified arguments.\n  args = collapseAliases(combinedSpec, args);\n\n  // Filter out array-type arguments so _resolveStringOrBooleanArgs can process the rest.\n  // This is necessary because _resolveStringOrBooleanArgs can't handle array-type args like --platform.\n  const filteredArgs = filterOutArrayArgs(args, combinedSpec);\n\n  // Resolve all of the string or boolean arguments and the project root.\n  return _resolveStringOrBooleanArgs(combinedSpec, filteredArgs, allowedValues);\n}\n\n/**\n * Enables the resolution of boolean arguments that can be formatted like `--foo=true` or `--foo false`\n *\n * @param argv arguments that were passed to the command.\n * @param rawArgMap base argument spec defining valid arguments and their types.\n * @param extraArgMap extra arguments and aliases that should be resolved as string or boolean.\n * @returns parsed arguments and project root.\n */\nexport async function resolveCustomBooleanArgsAsync(\n  argv: string[],\n  rawArgMap: arg.Spec,\n  extraArgMap: ExtraArgsSpec\n) {\n  const results = await resolveStringOrBooleanArgsAsync(argv, rawArgMap, extraArgMap);\n\n  return {\n    ...results,\n    args: Object.fromEntries(\n      Object.entries(results.args).map(([key, value]) => {\n        // Skip aliases (e.g. '-f': '--flag') - only process actual flags\n        const extraArgValue = extraArgMap[key];\n        if (extraArgValue && typeof extraArgValue !== 'string') {\n          if (typeof value === 'string') {\n            if (!['true', 'false'].includes(value)) {\n              throw new CommandError(\n                'BAD_ARGS',\n                `Invalid boolean argument: ${key}=${value}. Expected one of: true, false`\n              );\n            }\n            return [key, value === 'true'];\n          }\n        }\n        return [key, value];\n      })\n    ),\n  };\n}\n\nexport function _resolveStringOrBooleanArgs(\n  arg: Spec,\n  args: string[],\n  allowedValues?: Record<string, string[]>\n) {\n  // Default project root, if a custom one is defined then it will overwrite this.\n  let projectRoot: string = '.';\n  // The resolved arguments.\n  const settings: Record<string, string | boolean | undefined> = {};\n\n  // Create a list of possible arguments, this will filter out aliases.\n  const possibleArgs = Object.entries(arg)\n    .filter(([, value]) => typeof value !== 'string')\n    .map(([key]) => key);\n\n  // Check if a value is allowed for a given flag\n  const isAllowedValue = (flag: string, value: string): boolean => {\n    if (!allowedValues || !allowedValues[flag]) {\n      return true; // No restrictions, allow any value\n    }\n    return allowedValues[flag].includes(value);\n  };\n\n  // Loop over arguments in reverse order so we can resolve if a value belongs to a flag.\n  for (let i = args.length - 1; i > -1; i--) {\n    const value = args[i];\n    // At this point we should have converted all aliases to fully qualified arguments.\n    if (value.startsWith('--')) {\n      // If we ever find an argument then it must be a boolean because we are checking in reverse\n      // and removing arguments from the array if we find a string.\n      // We don't override arguments that are already set\n      if (!(value in settings)) {\n        settings[value] = true;\n      }\n    } else {\n      // Get the previous argument in the array.\n      const nextValue = i > 0 ? args[i - 1] : null;\n      if (nextValue && possibleArgs.includes(nextValue) && isAllowedValue(nextValue, value)) {\n        // We don't override arguments that are already set\n        if (!(nextValue in settings)) {\n          settings[nextValue] = value;\n        }\n        i--;\n      } else if (\n        // If the last value is not a flag and it doesn't have a recognized flag before it (instead having a string value or nothing)\n        // then it must be the project root.\n        i ===\n        args.length - 1\n      ) {\n        projectRoot = value;\n      } else {\n        // This will asserts if two strings are passed in a row and not at the end of the line.\n        throw new CommandError('BAD_ARGS', `Unknown argument: ${value}`);\n      }\n    }\n  }\n\n  return {\n    args: settings,\n    projectRoot,\n  };\n}\n\n/** Convert all aliases to fully qualified flag names. */\nexport function collapseAliases(arg: Spec, args: string[]): string[] {\n  const aliasMap = getAliasTuples(arg);\n\n  for (const [arg, alias] of aliasMap) {\n    args = replaceAllValues(args, arg, alias);\n  }\n\n  // Assert if there are duplicate flags after we collapse the aliases.\n  // Skip array-type arguments (like --platform) which can have multiple values.\n  assertDuplicateArgs(args, aliasMap, arg);\n  return args;\n}\n\n/** Assert that the spec has unknown arguments. */\nexport function assertUnknownArgs(arg: Spec, args: string[]) {\n  const allowedArgs = Object.keys(arg);\n  const unknownArgs = args.filter((arg) => !allowedArgs.includes(arg) && arg.startsWith('-'));\n  if (unknownArgs.length > 0) {\n    throw new CommandError(`Unknown arguments: ${unknownArgs.join(', ')}`);\n  }\n}\n\nfunction getAliasTuples(arg: Spec): [string, string][] {\n  return Object.entries(arg).filter(([, value]) => typeof value === 'string') as [string, string][];\n}\n\n/** Filter out array-type arguments from the spec (and their values).\n * This is needed because _resolveStringOrBooleanArgs can't handle array args like --platform.\n */\nfunction filterOutArrayArgs(args: string[], spec: Spec): string[] {\n  // Get the set of flag names that are array types\n  const arrayFlags = new Set(\n    Object.entries(spec)\n      .filter(([, value]) => Array.isArray(value))\n      .map(([key]) => key)\n  );\n\n  if (arrayFlags.size === 0) {\n    return args;\n  }\n\n  const result: string[] = [];\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n    if (arrayFlags.has(arg)) {\n      // Skip this flag and its value if it has one\n      if (i + 1 < args.length && !args[i + 1].startsWith('-')) {\n        i++;\n      }\n    } else {\n      result.push(arg);\n    }\n  }\n  return result;\n}\n\n/** Asserts that a duplicate flag has been used, this naively throws without knowing if an alias or flag were used as the duplicate. */\nexport function assertDuplicateArgs(\n  args: string[],\n  argNameAliasTuple: [string, string][],\n  spec?: Spec\n) {\n  for (const [argName, argNameAlias] of argNameAliasTuple) {\n    // Skip array-type arguments (like --platform) which can have multiple values\n    if (spec && Array.isArray(spec[argNameAlias])) {\n      continue;\n    }\n    if (args.filter((a) => [argName, argNameAlias].includes(a)).length > 1) {\n      throw new CommandError(\n        'BAD_ARGS',\n        `Can only provide one instance of ${argName} or ${argNameAlias}`\n      );\n    }\n  }\n}\n\nexport function assertNonBooleanArg(argName: string, arg: any): asserts arg is string | string[] {\n  if (arg == null || typeof arg === 'boolean') {\n    throw new CommandError('BAD_ARGS', `Expected input for arg ${argName}`);\n  }\n}\n"],"names":["_resolveStringOrBooleanArgs","assertDuplicateArgs","assertNonBooleanArg","assertUnknownArgs","collapseAliases","resolveCustomBooleanArgsAsync","resolveStringOrBooleanArgsAsync","parseExtraArgMap","extraArgMap","spec","allowedValues","key","value","Object","entries","Array","isArray","first","stringValues","Boolean","CommandError","splitArgs","args","result","arg","startsWith","props","split","push","length","join","argv","rawArgMap","extraArgSpec","combinedSpec","filteredArgs","filterOutArrayArgs","results","fromEntries","map","extraArgValue","includes","projectRoot","settings","possibleArgs","filter","isAllowedValue","flag","i","nextValue","aliasMap","getAliasTuples","alias","replaceAllValues","allowedArgs","keys","unknownArgs","arrayFlags","Set","size","has","argNameAliasTuple","argName","argNameAlias","a"],"mappings":";;;;;;;;;;;IAyIgBA,2BAA2B;eAA3BA;;IAyHAC,mBAAmB;eAAnBA;;IAmBAC,mBAAmB;eAAnBA;;IA9DAC,iBAAiB;eAAjBA;;IAdAC,eAAe;eAAfA;;IA9FMC,6BAA6B;eAA7BA;;IAhCAC,+BAA+B;eAA/BA;;;uBAzEW;wBACJ;AAU7B,iFAAiF,GACjF,SAASC,iBAAiBC,WAA0B;IAIlD,MAAMC,OAAiB,CAAC;IACxB,MAAMC,gBAA0C,CAAC;IAEjD,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACN,aAAc;QACtD,IAAI,OAAOI,UAAU,UAAU;YAC7B,8BAA8B;YAC9BH,IAAI,CAACE,IAAI,GAAGC;QACd,OAAO,IAAIG,MAAMC,OAAO,CAACJ,QAAQ;YAC/B,0FAA0F;YAC1F,MAAM,CAACK,OAAO,GAAGC,aAAa,GAAGN;YACjC,IAAIK,UAAUE,SAAS;gBACrB,MAAM,IAAIC,oBAAY,CACpB,YACA,CAAC,6BAA6B,EAAET,IAAI,+BAA+B,CAAC;YAExE;YACAF,IAAI,CAACE,IAAI,GAAGQ;YACZT,aAAa,CAACC,IAAI,GAAG;gBAAC;gBAAQ;mBAAYO;aAAa;QACzD,OAAO;YACL,8BAA8B;YAC9BT,IAAI,CAACE,IAAI,GAAGQ;QACd;IACF;IAEA,OAAO;QAAEV;QAAMC;IAAc;AAC/B;AAEA,+FAA+F,GAC/F,SAASW,UAAUC,IAAc;IAC/B,MAAMC,SAAmB,EAAE;IAE3B,KAAK,MAAMC,OAAOF,KAAM;QACtB,IAAIE,IAAIC,UAAU,CAAC,MAAM;YACvB,MAAM,CAACd,KAAK,GAAGe,MAAM,GAAGF,IAAIG,KAAK,CAAC;YAClCJ,OAAOK,IAAI,CAACjB;YACZ,IAAIe,MAAMG,MAAM,EAAE;gBAChBN,OAAOK,IAAI,CAACF,MAAMI,IAAI,CAAC;YACzB;QACF,OAAO;YACLP,OAAOK,IAAI,CAACJ;QACd;IACF;IAEA,OAAOD;AACT;AAaO,eAAejB,gCACpByB,IAAc,EACdC,SAAmB,EACnBxB,WAA0B;IAE1B,IAAIc,OAAOD,UAAUU;IAErB,MAAM,EAAEtB,MAAMwB,YAAY,EAAEvB,aAAa,EAAE,GAAGH,iBAAiBC;IAC/D,MAAM0B,eAAe;QAAE,GAAGF,SAAS;QAAE,GAAGC,YAAY;IAAC;IAErD,+BAA+B;IAC/B9B,kBAAkB+B,cAAcZ;IAEhC,mDAAmD;IACnDA,OAAOlB,gBAAgB8B,cAAcZ;IAErC,uFAAuF;IACvF,sGAAsG;IACtG,MAAMa,eAAeC,mBAAmBd,MAAMY;IAE9C,uEAAuE;IACvE,OAAOlC,4BAA4BkC,cAAcC,cAAczB;AACjE;AAUO,eAAeL,8BACpB0B,IAAc,EACdC,SAAmB,EACnBxB,WAA0B;IAE1B,MAAM6B,UAAU,MAAM/B,gCAAgCyB,MAAMC,WAAWxB;IAEvE,OAAO;QACL,GAAG6B,OAAO;QACVf,MAAMT,OAAOyB,WAAW,CACtBzB,OAAOC,OAAO,CAACuB,QAAQf,IAAI,EAAEiB,GAAG,CAAC,CAAC,CAAC5B,KAAKC,MAAM;YAC5C,iEAAiE;YACjE,MAAM4B,gBAAgBhC,WAAW,CAACG,IAAI;YACtC,IAAI6B,iBAAiB,OAAOA,kBAAkB,UAAU;gBACtD,IAAI,OAAO5B,UAAU,UAAU;oBAC7B,IAAI,CAAC;wBAAC;wBAAQ;qBAAQ,CAAC6B,QAAQ,CAAC7B,QAAQ;wBACtC,MAAM,IAAIQ,oBAAY,CACpB,YACA,CAAC,0BAA0B,EAAET,IAAI,CAAC,EAAEC,MAAM,8BAA8B,CAAC;oBAE7E;oBACA,OAAO;wBAACD;wBAAKC,UAAU;qBAAO;gBAChC;YACF;YACA,OAAO;gBAACD;gBAAKC;aAAM;QACrB;IAEJ;AACF;AAEO,SAASZ,4BACdwB,GAAS,EACTF,IAAc,EACdZ,aAAwC;IAExC,gFAAgF;IAChF,IAAIgC,cAAsB;IAC1B,0BAA0B;IAC1B,MAAMC,WAAyD,CAAC;IAEhE,qEAAqE;IACrE,MAAMC,eAAe/B,OAAOC,OAAO,CAACU,KACjCqB,MAAM,CAAC,CAAC,GAAGjC,MAAM,GAAK,OAAOA,UAAU,UACvC2B,GAAG,CAAC,CAAC,CAAC5B,IAAI,GAAKA;IAElB,+CAA+C;IAC/C,MAAMmC,iBAAiB,CAACC,MAAcnC;QACpC,IAAI,CAACF,iBAAiB,CAACA,aAAa,CAACqC,KAAK,EAAE;YAC1C,OAAO,MAAM,mCAAmC;QAClD;QACA,OAAOrC,aAAa,CAACqC,KAAK,CAACN,QAAQ,CAAC7B;IACtC;IAEA,uFAAuF;IACvF,IAAK,IAAIoC,IAAI1B,KAAKO,MAAM,GAAG,GAAGmB,IAAI,CAAC,GAAGA,IAAK;QACzC,MAAMpC,QAAQU,IAAI,CAAC0B,EAAE;QACrB,mFAAmF;QACnF,IAAIpC,MAAMa,UAAU,CAAC,OAAO;YAC1B,2FAA2F;YAC3F,6DAA6D;YAC7D,mDAAmD;YACnD,IAAI,CAAEb,CAAAA,SAAS+B,QAAO,GAAI;gBACxBA,QAAQ,CAAC/B,MAAM,GAAG;YACpB;QACF,OAAO;YACL,0CAA0C;YAC1C,MAAMqC,YAAYD,IAAI,IAAI1B,IAAI,CAAC0B,IAAI,EAAE,GAAG;YACxC,IAAIC,aAAaL,aAAaH,QAAQ,CAACQ,cAAcH,eAAeG,WAAWrC,QAAQ;gBACrF,mDAAmD;gBACnD,IAAI,CAAEqC,CAAAA,aAAaN,QAAO,GAAI;oBAC5BA,QAAQ,CAACM,UAAU,GAAGrC;gBACxB;gBACAoC;YACF,OAAO,IACL,6HAA6H;YAC7H,oCAAoC;YACpCA,MACA1B,KAAKO,MAAM,GAAG,GACd;gBACAa,cAAc9B;YAChB,OAAO;gBACL,uFAAuF;gBACvF,MAAM,IAAIQ,oBAAY,CAAC,YAAY,CAAC,kBAAkB,EAAER,OAAO;YACjE;QACF;IACF;IAEA,OAAO;QACLU,MAAMqB;QACND;IACF;AACF;AAGO,SAAStC,gBAAgBoB,GAAS,EAAEF,IAAc;IACvD,MAAM4B,WAAWC,eAAe3B;IAEhC,KAAK,MAAM,CAACA,KAAK4B,MAAM,IAAIF,SAAU;QACnC5B,OAAO+B,IAAAA,uBAAgB,EAAC/B,MAAME,KAAK4B;IACrC;IAEA,qEAAqE;IACrE,8EAA8E;IAC9EnD,oBAAoBqB,MAAM4B,UAAU1B;IACpC,OAAOF;AACT;AAGO,SAASnB,kBAAkBqB,GAAS,EAAEF,IAAc;IACzD,MAAMgC,cAAczC,OAAO0C,IAAI,CAAC/B;IAChC,MAAMgC,cAAclC,KAAKuB,MAAM,CAAC,CAACrB,MAAQ,CAAC8B,YAAYb,QAAQ,CAACjB,QAAQA,IAAIC,UAAU,CAAC;IACtF,IAAI+B,YAAY3B,MAAM,GAAG,GAAG;QAC1B,MAAM,IAAIT,oBAAY,CAAC,CAAC,mBAAmB,EAAEoC,YAAY1B,IAAI,CAAC,OAAO;IACvE;AACF;AAEA,SAASqB,eAAe3B,GAAS;IAC/B,OAAOX,OAAOC,OAAO,CAACU,KAAKqB,MAAM,CAAC,CAAC,GAAGjC,MAAM,GAAK,OAAOA,UAAU;AACpE;AAEA;;CAEC,GACD,SAASwB,mBAAmBd,IAAc,EAAEb,IAAU;IACpD,iDAAiD;IACjD,MAAMgD,aAAa,IAAIC,IACrB7C,OAAOC,OAAO,CAACL,MACZoC,MAAM,CAAC,CAAC,GAAGjC,MAAM,GAAKG,MAAMC,OAAO,CAACJ,QACpC2B,GAAG,CAAC,CAAC,CAAC5B,IAAI,GAAKA;IAGpB,IAAI8C,WAAWE,IAAI,KAAK,GAAG;QACzB,OAAOrC;IACT;IAEA,MAAMC,SAAmB,EAAE;IAC3B,IAAK,IAAIyB,IAAI,GAAGA,IAAI1B,KAAKO,MAAM,EAAEmB,IAAK;QACpC,MAAMxB,MAAMF,IAAI,CAAC0B,EAAE;QACnB,IAAIS,WAAWG,GAAG,CAACpC,MAAM;YACvB,6CAA6C;YAC7C,IAAIwB,IAAI,IAAI1B,KAAKO,MAAM,IAAI,CAACP,IAAI,CAAC0B,IAAI,EAAE,CAACvB,UAAU,CAAC,MAAM;gBACvDuB;YACF;QACF,OAAO;YACLzB,OAAOK,IAAI,CAACJ;QACd;IACF;IACA,OAAOD;AACT;AAGO,SAAStB,oBACdqB,IAAc,EACduC,iBAAqC,EACrCpD,IAAW;IAEX,KAAK,MAAM,CAACqD,SAASC,aAAa,IAAIF,kBAAmB;QACvD,6EAA6E;QAC7E,IAAIpD,QAAQM,MAAMC,OAAO,CAACP,IAAI,CAACsD,aAAa,GAAG;YAC7C;QACF;QACA,IAAIzC,KAAKuB,MAAM,CAAC,CAACmB,IAAM;gBAACF;gBAASC;aAAa,CAACtB,QAAQ,CAACuB,IAAInC,MAAM,GAAG,GAAG;YACtE,MAAM,IAAIT,oBAAY,CACpB,YACA,CAAC,iCAAiC,EAAE0C,QAAQ,IAAI,EAAEC,cAAc;QAEpE;IACF;AACF;AAEO,SAAS7D,oBAAoB4D,OAAe,EAAEtC,GAAQ;IAC3D,IAAIA,OAAO,QAAQ,OAAOA,QAAQ,WAAW;QAC3C,MAAM,IAAIJ,oBAAY,CAAC,YAAY,CAAC,uBAAuB,EAAE0C,SAAS;IACxE;AACF"}