@glodon-aiot/agent-cli-ui 3.19.0-alpha.30 → 3.19.0-beta.31

package/dist/es/node_modules/refractor/lang/excel-formula.mjs

@@ -1,74 +0,0 @@
-var r, t;
-function n() {
-  if (t)
-    return r;
-  t = 1, r = a, a.displayName = "excelFormula", a.aliases = [];
-  function a(e) {
-    e.languages["excel-formula"] = {
-      comment: {
-        pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
-        lookbehind: !0,
-        greedy: !0
-      },
-      string: {
-        pattern: /"(?:[^"]|"")*"(?!")/,
-        greedy: !0
-      },
-      reference: {
-        // https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
-        // Sales!B2
-        // 'Winter sales'!B2
-        // [Sales.xlsx]Jan!B2:B5
-        // D:\Reports\[Sales.xlsx]Jan!B2:B5
-        // '[Sales.xlsx]Jan sales'!B2:B5
-        // 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
-        pattern: /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
-        greedy: !0,
-        alias: "string",
-        inside: {
-          operator: /!$/,
-          punctuation: /'/,
-          sheet: {
-            pattern: /[^[\]]+$/,
-            alias: "function"
-          },
-          file: {
-            pattern: /\[[^[\]]+\]$/,
-            inside: {
-              punctuation: /[[\]]/
-            }
-          },
-          path: /[\s\S]+/
-        }
-      },
-      "function-name": {
-        pattern: /\b[A-Z]\w*(?=\()/i,
-        alias: "keyword"
-      },
-      range: {
-        pattern: /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
-        alias: "property",
-        inside: {
-          operator: /:/,
-          cell: /\$?[A-Z]+\$?\d+/i,
-          column: /\$?[A-Z]+/i,
-          row: /\$?\d+/
-        }
-      },
-      cell: {
-        // Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
-        // To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
-        pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
-        alias: "property"
-      },
-      number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
-      boolean: /\b(?:FALSE|TRUE)\b/i,
-      operator: /[-+*/^%=&,]|<[=>]?|>=?/,
-      punctuation: /[[\]();{}|]/
-    }, e.languages.xlsx = e.languages.xls = e.languages["excel-formula"];
-  }
-  return r;
-}
-export {
-  n as __require
-};

package/dist/es/node_modules/refractor/lang/factor.mjs

@@ -1,569 +0,0 @@
-var n, l;
-function m() {
-  if (l)
-    return n;
-  l = 1, n = r, r.displayName = "factor", r.aliases = [];
-  function r(u) {
-    (function(p) {
-      var i = {
-        function: /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
-      }, t = {
-        number: /\\[^\s']|%\w/
-      }, s = {
-        comment: [
-          {
-            // ! single-line exclamation point comments with whitespace after/around the !
-            pattern: /(^|\s)(?:! .*|!$)/,
-            lookbehind: !0,
-            inside: i
-          },
-          /* from basis/multiline: */
-          {
-            // /* comment */, /* comment*/
-            pattern: /(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,
-            lookbehind: !0,
-            greedy: !0,
-            inside: i
-          },
-          {
-            // ![[ comment ]] , ![===[ comment]===]
-            pattern: /(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
-            lookbehind: !0,
-            greedy: !0,
-            inside: i
-          }
-        ],
-        number: [{
-          // basic base 10 integers 9, -9
-          pattern: /(^|\s)[+-]?\d+(?=\s|$)/,
-          lookbehind: !0
-        }, {
-          // base prefix integers 0b010 0o70 0xad 0d10 0XAD -0xa9
-          pattern: /(^|\s)[+-]?0(?:b[01]+|o[0-7]+|d\d+|x[\dA-F]+)(?=\s|$)/i,
-          lookbehind: !0
-        }, {
-          // fractional ratios 1/5 -1/5 and the literal float approximations 1/5. -1/5.
-          pattern: /(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/,
-          lookbehind: !0
-        }, {
-          // positive mixed numbers 23+1/5 +23+1/5
-          pattern: /(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/,
-          lookbehind: !0
-        }, {
-          // negative mixed numbers -23-1/5
-          pattern: /(^|\s)-\d+-\d+\/\d+(?=\s|$)/,
-          lookbehind: !0
-        }, {
-          // basic decimal floats -0.01 0. .0 .1 -.1 -1. -12.13 +12.13
-          // and scientific notation with base 10 exponents 3e4 3e-4 .3e-4
-          pattern: /(^|\s)[+-]?(?:\d*\.\d+|\d+\.\d*|\d+)(?:e[+-]?\d+)?(?=\s|$)/i,
-          lookbehind: !0
-        }, {
-          // NAN literal syntax NAN: 80000deadbeef, NAN: a
-          pattern: /(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/,
-          lookbehind: !0
-        }, {
-          /*
-          base prefix floats 0x1.0p3 (8.0) 0b1.010p2 (5.0) 0x1.p1 0b1.11111111p11111...
-          "The normalized hex form ±0x1.MMMMMMMMMMMMM[pP]±EEEE allows any floating-point number to be specified precisely.
-          The values of MMMMMMMMMMMMM and EEEE map directly to the mantissa and exponent fields of the binary IEEE 754 representation."
-          <https://docs.factorcode.org/content/article-syntax-floats.html>
-          */
-          pattern: /(^|\s)[+-]?0(?:b1\.[01]*|o1\.[0-7]*|d1\.\d*|x1\.[\dA-F]*)p\d+(?=\s|$)/i,
-          lookbehind: !0
-        }],
-        // R/ regexp?\/\\/
-        regexp: {
-          pattern: /(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
-          lookbehind: !0,
-          alias: "number",
-          inside: {
-            variable: /\\\S/,
-            keyword: /[+?*\[\]^$(){}.|]/,
-            operator: {
-              pattern: /(\/)[idmsr]+(?:-[idmsr]+)?/,
-              lookbehind: !0
-            }
-          }
-        },
-        boolean: {
-          pattern: /(^|\s)[tf](?=\s|$)/,
-          lookbehind: !0
-        },
-        // SBUF" asd", URL" ://...", P" /etc/"
-        "custom-string": {
-          pattern: /(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "string",
-          inside: {
-            number: /\\\S|%\w|\//
-          }
-        },
-        "multiline-string": [{
-          // STRING: name \n content \n ; -> CONSTANT: name "content" (symbol)
-          pattern: /(^|\s)STRING:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*;(?=\s|$)/,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "string",
-          inside: {
-            number: t.number,
-            // trailing semicolon on its own line
-            "semicolon-or-setlocal": {
-              pattern: /([\r\n][ \t]*);(?=\s|$)/,
-              lookbehind: !0,
-              alias: "function"
-            }
-          }
-        }, {
-          // HEREDOC: marker \n content \n marker ; -> "content" (immediate)
-          pattern: /(^|\s)HEREDOC:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*\S+(?=\s|$)/,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "string",
-          inside: t
-        }, {
-          // [[ string ]], [==[ string]==]
-          pattern: /(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "string",
-          inside: t
-        }],
-        "special-using": {
-          pattern: /(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,
-          lookbehind: !0,
-          alias: "function",
-          inside: {
-            // this is essentially a regex for vocab names, which i don't want to specify
-            // but the USING: gets picked up as a vocab name
-            string: {
-              pattern: /(\s)[^:\s]+/,
-              lookbehind: !0
-            }
-          }
-        },
-        /* this description of stack effect literal syntax is not complete and not as specific as theoretically possible
-        trying to do better is more work and regex-computation-time than it's worth though.
-        - we'd like to have the "delimiter" parts of the stack effect [ (, --, and ) ] be a different (less-important or comment-like) colour to the stack effect contents
-        - we'd like if nested stack effects were treated as such rather than just appearing flat (with `inside`)
-        - we'd like if the following variable name conventions were recognised specifically:
-        special row variables = ..a b..
-        type and stack effect annotations end with a colon = ( quot: ( a: ( -- ) -- b ) -- x ), ( x: number -- )
-        word throws unconditional error = *
-        any other word-like variable name = a ? q' etc
-        https://docs.factorcode.org/content/article-effects.html
-        these are pretty complicated to highlight properly without a real parser, and therefore out of scope
-        the old pattern, which may be later useful, was: (^|\s)(?:call|execute|eval)?\((?:\s+[^"\r\n\t ]\S*)*?\s+--(?:\s+[^"\n\t ]\S*)*?\s+\)(?=\s|$)
-        */
-        // current solution is not great
-        "stack-effect-delimiter": [{
-          // opening parenthesis
-          pattern: /(^|\s)(?:call|eval|execute)?\((?=\s)/,
-          lookbehind: !0,
-          alias: "operator"
-        }, {
-          // middle --
-          pattern: /(\s)--(?=\s)/,
-          lookbehind: !0,
-          alias: "operator"
-        }, {
-          // closing parenthesis
-          pattern: /(\s)\)(?=\s|$)/,
-          lookbehind: !0,
-          alias: "operator"
-        }],
-        combinators: {
-          pattern: null,
-          lookbehind: !0,
-          alias: "keyword"
-        },
-        "kernel-builtin": {
-          pattern: null,
-          lookbehind: !0,
-          alias: "variable"
-        },
-        "sequences-builtin": {
-          pattern: null,
-          lookbehind: !0,
-          alias: "variable"
-        },
-        "math-builtin": {
-          pattern: null,
-          lookbehind: !0,
-          alias: "variable"
-        },
-        "constructor-word": {
-          // <array> but not <=>
-          pattern: /(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,
-          lookbehind: !0,
-          alias: "keyword"
-        },
-        "other-builtin-syntax": {
-          pattern: null,
-          lookbehind: !0,
-          alias: "operator"
-        },
-        /*
-        full list of supported word naming conventions: (the convention appears outside of the [brackets])
-        set-[x]
-        change-[x]
-        with-[x]
-        new-[x]
-        >[string]
-        [base]>
-        [string]>[number]
-        +[symbol]+
-        [boolean-word]?
-        ?[of]
-        [slot-reader]>>
-        >>[slot-setter]
-        [slot-writer]<<
-        ([implementation-detail])
-        [mutater]!
-        [variant]*
-        [prettyprint].
-        $[help-markup]
-        <constructors>, SYNTAX:, etc are supported by their own patterns.
-        `with` and `new` from `kernel` are their own builtins.
-        see <https://docs.factorcode.org/content/article-conventions.html>
-        */
-        "conventionally-named-word": {
-          pattern: /(^|\s)(?!")(?:(?:change|new|set|with)-\S+|\$\S+|>[^>\s]+|[^:>\s]+>|[^>\s]+>[^>\s]+|\+[^+\s]+\+|[^?\s]+\?|\?[^?\s]+|[^>\s]+>>|>>[^>\s]+|[^<\s]+<<|\([^()\s]+\)|[^!\s]+!|[^*\s]\S*\*|[^.\s]\S*\.)(?=\s|$)/,
-          lookbehind: !0,
-          alias: "keyword"
-        },
-        "colon-syntax": {
-          pattern: /(^|\s)(?:[A-Z0-9\-]+#?)?:{1,2}\s+(?:;\S+|(?!;)\S+)(?=\s|$)/,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "function"
-        },
-        "semicolon-or-setlocal": {
-          pattern: /(\s)(?:;|:>)(?=\s|$)/,
-          lookbehind: !0,
-          alias: "function"
-        },
-        // do not highlight leading } or trailing X{ at the begin/end of the file as it's invalid syntax
-        "curly-brace-literal-delimiter": [{
-          // opening
-          pattern: /(^|\s)[a-z]*\{(?=\s)/i,
-          lookbehind: !0,
-          alias: "operator"
-        }, {
-          // closing
-          pattern: /(\s)\}(?=\s|$)/,
-          lookbehind: !0,
-          alias: "operator"
-        }],
-        // do not highlight leading ] or trailing [ at the begin/end of the file as it's invalid syntax
-        "quotation-delimiter": [{
-          // opening
-          pattern: /(^|\s)\[(?=\s)/,
-          lookbehind: !0,
-          alias: "operator"
-        }, {
-          // closing
-          pattern: /(\s)\](?=\s|$)/,
-          lookbehind: !0,
-          alias: "operator"
-        }],
-        "normal-word": {
-          pattern: /(^|\s)[^"\s]\S*(?=\s|$)/,
-          lookbehind: !0
-        },
-        /*
-        basic first-class string "a"
-        with escaped double-quote "a\""
-        escaped backslash "\\"
-        and general escapes since Factor has so many "\N"
-        syntax that works in the reference implementation that isn't fully
-        supported because it's an implementation detail:
-        "string 1""string 2" -> 2 strings (works anyway)
-        "string"5 -> string, 5
-        "string"[ ] -> string, quotation
-        { "a"} -> array<string>
-        the rest of those examples all properly recognise the string, but not
-        the other object (number, quotation, etc)
-        this is fine for a regex-only implementation.
-        */
-        string: {
-          pattern: /"(?:\\\S|[^"\\])*"/,
-          greedy: !0,
-          inside: t
-        }
-      }, d = function(e) {
-        return (e + "").replace(/([.?*+\^$\[\]\\(){}|\-])/g, "\\$1");
-      }, a = function(e) {
-        return new RegExp("(^|\\s)(?:" + e.map(d).join("|") + ")(?=\\s|$)");
-      }, o = {
-        "kernel-builtin": ["or", "2nipd", "4drop", "tuck", "wrapper", "nip", "wrapper?", "callstack>array", "die", "dupd", "callstack", "callstack?", "3dup", "hashcode", "pick", "4nip", "build", ">boolean", "nipd", "clone", "5nip", "eq?", "?", "=", "swapd", "2over", "clear", "2dup", "get-retainstack", "not", "tuple?", "dup", "3nipd", "call", "-rotd", "object", "drop", "assert=", "assert?", "-rot", "execute", "boa", "get-callstack", "curried?", "3drop", "pickd", "overd", "over", "roll", "3nip", "swap", "and", "2nip", "rotd", "throw", "(clone)", "hashcode*", "spin", "reach", "4dup", "equal?", "get-datastack", "assert", "2drop", "<wrapper>", "boolean?", "identity-hashcode", "identity-tuple?", "null", "composed?", "new", "5drop", "rot", "-roll", "xor", "identity-tuple", "boolean"],
-        "other-builtin-syntax": [
-          // syntax
-          "=======",
-          "recursive",
-          "flushable",
-          ">>",
-          "<<<<<<",
-          "M\\",
-          "B",
-          "PRIVATE>",
-          "\\",
-          "======",
-          "final",
-          "inline",
-          "delimiter",
-          "deprecated",
-          "<PRIVATE",
-          ">>>>>>",
-          "<<<<<<<",
-          "parse-complex",
-          "malformed-complex",
-          "read-only",
-          ">>>>>>>",
-          "call-next-method",
-          "<<",
-          "foldable",
-          // literals
-          "$",
-          "$[",
-          "${"
-        ],
-        "sequences-builtin": ["member-eq?", "mismatch", "append", "assert-sequence=", "longer", "repetition", "clone-like", "3sequence", "assert-sequence?", "last-index-from", "reversed", "index-from", "cut*", "pad-tail", "join-as", "remove-eq!", "concat-as", "but-last", "snip", "nths", "nth", "sequence", "longest", "slice?", "<slice>", "remove-nth", "tail-slice", "empty?", "tail*", "member?", "virtual-sequence?", "set-length", "drop-prefix", "iota", "unclip", "bounds-error?", "unclip-last-slice", "non-negative-integer-expected", "non-negative-integer-expected?", "midpoint@", "longer?", "?set-nth", "?first", "rest-slice", "prepend-as", "prepend", "fourth", "sift", "subseq-start", "new-sequence", "?last", "like", "first4", "1sequence", "reverse", "slice", "virtual@", "repetition?", "set-last", "index", "4sequence", "max-length", "set-second", "immutable-sequence", "first2", "first3", "supremum", "unclip-slice", "suffix!", "insert-nth", "tail", "3append", "short", "suffix", "concat", "flip", "immutable?", "reverse!", "2sequence", "sum", "delete-all", "indices", "snip-slice", "<iota>", "check-slice", "sequence?", "head", "append-as", "halves", "sequence=", "collapse-slice", "?second", "slice-error?", "product", "bounds-check?", "bounds-check", "immutable", "virtual-exemplar", "harvest", "remove", "pad-head", "last", "set-fourth", "cartesian-product", "remove-eq", "shorten", "shorter", "reversed?", "shorter?", "shortest", "head-slice", "pop*", "tail-slice*", "but-last-slice", "iota?", "append!", "cut-slice", "new-resizable", "head-slice*", "sequence-hashcode", "pop", "set-nth", "?nth", "second", "join", "immutable-sequence?", "<reversed>", "3append-as", "virtual-sequence", "subseq?", "remove-nth!", "length", "last-index", "lengthen", "assert-sequence", "copy", "move", "third", "first", "tail?", "set-first", "prefix", "bounds-error", "<repetition>", "exchange", "surround", "cut", "min-length", "set-third", "push-all", "head?", "subseq-start-from", "delete-slice", "rest", "sum-lengths", "head*", "infimum", "remove!", "glue", "slice-error", "subseq", "push", "replace-slice", "subseq-as", "unclip-last"],
-        "math-builtin": ["number=", "next-power-of-2", "?1+", "fp-special?", "imaginary-part", "float>bits", "number?", "fp-infinity?", "bignum?", "fp-snan?", "denominator", "gcd", "*", "+", "fp-bitwise=", "-", "u>=", "/", ">=", "bitand", "power-of-2?", "log2-expects-positive", "neg?", "<", "log2", ">", "integer?", "number", "bits>double", "2/", "zero?", "bits>float", "float?", "shift", "ratio?", "rect>", "even?", "ratio", "fp-sign", "bitnot", ">fixnum", "complex?", "/i", "integer>fixnum", "/f", "sgn", ">bignum", "next-float", "u<", "u>", "mod", "recip", "rational", ">float", "2^", "integer", "fixnum?", "neg", "fixnum", "sq", "bignum", ">rect", "bit?", "fp-qnan?", "simple-gcd", "complex", "<fp-nan>", "real", ">fraction", "double>bits", "bitor", "rem", "fp-nan-payload", "real-part", "log2-expects-positive?", "prev-float", "align", "unordered?", "float", "fp-nan?", "abs", "bitxor", "integer>fixnum-strict", "u<=", "odd?", "<=", "/mod", ">integer", "real?", "rational?", "numerator"]
-        // that's all for now
-      };
-      Object.keys(o).forEach(function(e) {
-        s[e].pattern = a(o[e]);
-      });
-      var c = [
-        // kernel
-        "2bi",
-        "while",
-        "2tri",
-        "bi*",
-        "4dip",
-        "both?",
-        "same?",
-        "tri@",
-        "curry",
-        "prepose",
-        "3bi",
-        "?if",
-        "tri*",
-        "2keep",
-        "3keep",
-        "curried",
-        "2keepd",
-        "when",
-        "2bi*",
-        "2tri*",
-        "4keep",
-        "bi@",
-        "keepdd",
-        "do",
-        "unless*",
-        "tri-curry",
-        "if*",
-        "loop",
-        "bi-curry*",
-        "when*",
-        "2bi@",
-        "2tri@",
-        "with",
-        "2with",
-        "either?",
-        "bi",
-        "until",
-        "3dip",
-        "3curry",
-        "tri-curry*",
-        "tri-curry@",
-        "bi-curry",
-        "keepd",
-        "compose",
-        "2dip",
-        "if",
-        "3tri",
-        "unless",
-        "tuple",
-        "keep",
-        "2curry",
-        "tri",
-        "most",
-        "while*",
-        "dip",
-        "composed",
-        "bi-curry@",
-        // sequences
-        "find-last-from",
-        "trim-head-slice",
-        "map-as",
-        "each-from",
-        "none?",
-        "trim-tail",
-        "partition",
-        "if-empty",
-        "accumulate*",
-        "reject!",
-        "find-from",
-        "accumulate-as",
-        "collector-for-as",
-        "reject",
-        "map",
-        "map-sum",
-        "accumulate!",
-        "2each-from",
-        "follow",
-        "supremum-by",
-        "map!",
-        "unless-empty",
-        "collector",
-        "padding",
-        "reduce-index",
-        "replicate-as",
-        "infimum-by",
-        "trim-tail-slice",
-        "count",
-        "find-index",
-        "filter",
-        "accumulate*!",
-        "reject-as",
-        "map-integers",
-        "map-find",
-        "reduce",
-        "selector",
-        "interleave",
-        "2map",
-        "filter-as",
-        "binary-reduce",
-        "map-index-as",
-        "find",
-        "produce",
-        "filter!",
-        "replicate",
-        "cartesian-map",
-        "cartesian-each",
-        "find-index-from",
-        "map-find-last",
-        "3map-as",
-        "3map",
-        "find-last",
-        "selector-as",
-        "2map-as",
-        "2map-reduce",
-        "accumulate",
-        "each",
-        "each-index",
-        "accumulate*-as",
-        "when-empty",
-        "all?",
-        "collector-as",
-        "push-either",
-        "new-like",
-        "collector-for",
-        "2selector",
-        "push-if",
-        "2all?",
-        "map-reduce",
-        "3each",
-        "any?",
-        "trim-slice",
-        "2reduce",
-        "change-nth",
-        "produce-as",
-        "2each",
-        "trim",
-        "trim-head",
-        "cartesian-find",
-        "map-index",
-        // math
-        "if-zero",
-        "each-integer",
-        "unless-zero",
-        "(find-integer)",
-        "when-zero",
-        "find-last-integer",
-        "(all-integers?)",
-        "times",
-        "(each-integer)",
-        "find-integer",
-        "all-integers?",
-        // math.combinators
-        "unless-negative",
-        "if-positive",
-        "when-positive",
-        "when-negative",
-        "unless-positive",
-        "if-negative",
-        // combinators
-        "case",
-        "2cleave",
-        "cond>quot",
-        "case>quot",
-        "3cleave",
-        "wrong-values",
-        "to-fixed-point",
-        "alist>quot",
-        "cond",
-        "cleave",
-        "call-effect",
-        "recursive-hashcode",
-        "spread",
-        "deep-spread>quot",
-        // combinators.short-circuit
-        "2||",
-        "0||",
-        "n||",
-        "0&&",
-        "2&&",
-        "3||",
-        "1||",
-        "1&&",
-        "n&&",
-        "3&&",
-        // combinators.smart
-        "smart-unless*",
-        "keep-inputs",
-        "reduce-outputs",
-        "smart-when*",
-        "cleave>array",
-        "smart-with",
-        "smart-apply",
-        "smart-if",
-        "inputs/outputs",
-        "output>sequence-n",
-        "map-outputs",
-        "map-reduce-outputs",
-        "dropping",
-        "output>array",
-        "smart-map-reduce",
-        "smart-2map-reduce",
-        "output>array-n",
-        "nullary",
-        "input<sequence",
-        "append-outputs",
-        "drop-inputs",
-        "inputs",
-        "smart-2reduce",
-        "drop-outputs",
-        "smart-reduce",
-        "preserving",
-        "smart-when",
-        "outputs",
-        "append-outputs-as",
-        "smart-unless",
-        "smart-if*",
-        "sum-outputs",
-        "input<sequence-unsafe",
-        "output>sequence"
-        // tafn
-      ];
-      s.combinators.pattern = a(c), p.languages.factor = s;
-    })(u);
-  }
-  return n;
-}
-export {
-  m as __require
-};

package/dist/es/node_modules/refractor/lang/false.mjs

@@ -1,39 +0,0 @@
-var e, r;
-function s() {
-  if (r)
-    return e;
-  r = 1, e = a, a.displayName = "$false", a.aliases = [];
-  function a(t) {
-    (function(n) {
-      n.languages.false = {
-        comment: {
-          pattern: /\{[^}]*\}/
-        },
-        string: {
-          pattern: /"[^"]*"/,
-          greedy: !0
-        },
-        "character-code": {
-          pattern: /'(?:[^\r]|\r\n?)/,
-          alias: "number"
-        },
-        "assembler-code": {
-          pattern: /\d+`/,
-          alias: "important"
-        },
-        number: /\d+/,
-        operator: /[-!#$%&'*+,./:;=>?@\\^_`|~ßø]/,
-        punctuation: /\[|\]/,
-        variable: /[a-z]/,
-        "non-standard": {
-          pattern: /[()<BDO®]/,
-          alias: "bold"
-        }
-      };
-    })(t);
-  }
-  return e;
-}
-export {
-  s as __require
-};