@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-NVDNGRDN.mjs

@@ -1,931 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/factor.js
-factor.displayName = "factor";
-factor.aliases = [];
-function factor(Prism) {
-  ;
-  (function(Prism2) {
-    var comment_inside = {
-      function: /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/
-    };
-    var string_inside = {
-      number: /\\[^\s']|%\w/
-    };
-    var factor2 = {
-      comment: [
-        {
-          // ! single-line exclamation point comments with whitespace after/around the !
-          pattern: /(^|\s)(?:! .*|!$)/,
-          lookbehind: true,
-          inside: comment_inside
-        },
-        {
-          // /* comment */, /* comment*/
-          pattern: /(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          inside: comment_inside
-        },
-        {
-          // ![[ comment ]] , ![===[ comment]===]
-          pattern: /(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          inside: comment_inside
-        }
-      ],
-      number: [
-        {
-          // basic base 10 integers 9, -9
-          pattern: /(^|\s)[+-]?\d+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // 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: true
-        },
-        {
-          // fractional ratios 1/5 -1/5 and the literal float approximations 1/5. -1/5.
-          pattern: /(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // positive mixed numbers 23+1/5 +23+1/5
-          pattern: /(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // negative mixed numbers -23-1/5
-          pattern: /(^|\s)-\d+-\d+\/\d+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          // 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: true
-        },
-        {
-          // NAN literal syntax NAN: 80000deadbeef, NAN: a
-          pattern: /(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/,
-          lookbehind: true
-        },
-        {
-          /*
-          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: true
-        }
-      ],
-      // R/ regexp?\/\\/
-      regexp: {
-        pattern: /(^|\s)R\/\s(?:\\\S|[^\\/])*\/(?:[idmsr]*|[idmsr]+-[idmsr]+)(?=\s|$)/,
-        lookbehind: true,
-        alias: "number",
-        inside: {
-          variable: /\\\S/,
-          keyword: /[+?*\[\]^$(){}.|]/,
-          operator: {
-            pattern: /(\/)[idmsr]+(?:-[idmsr]+)?/,
-            lookbehind: true
-          }
-        }
-      },
-      boolean: {
-        pattern: /(^|\s)[tf](?=\s|$)/,
-        lookbehind: true
-      },
-      // SBUF" asd", URL" ://...", P" /etc/"
-      "custom-string": {
-        pattern: /(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,
-        lookbehind: true,
-        greedy: true,
-        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: true,
-          greedy: true,
-          alias: "string",
-          inside: {
-            number: string_inside.number,
-            // trailing semicolon on its own line
-            "semicolon-or-setlocal": {
-              pattern: /([\r\n][ \t]*);(?=\s|$)/,
-              lookbehind: true,
-              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: true,
-          greedy: true,
-          alias: "string",
-          inside: string_inside
-        },
-        {
-          // [[ string ]], [==[ string]==]
-          pattern: /(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
-          lookbehind: true,
-          greedy: true,
-          alias: "string",
-          inside: string_inside
-        }
-      ],
-      "special-using": {
-        pattern: /(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,
-        lookbehind: true,
-        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: true
-          }
-        }
-      },
-      /* 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: true,
-          alias: "operator"
-        },
-        {
-          // middle --
-          pattern: /(\s)--(?=\s)/,
-          lookbehind: true,
-          alias: "operator"
-        },
-        {
-          // closing parenthesis
-          pattern: /(\s)\)(?=\s|$)/,
-          lookbehind: true,
-          alias: "operator"
-        }
-      ],
-      combinators: {
-        pattern: null,
-        lookbehind: true,
-        alias: "keyword"
-      },
-      "kernel-builtin": {
-        pattern: null,
-        lookbehind: true,
-        alias: "variable"
-      },
-      "sequences-builtin": {
-        pattern: null,
-        lookbehind: true,
-        alias: "variable"
-      },
-      "math-builtin": {
-        pattern: null,
-        lookbehind: true,
-        alias: "variable"
-      },
-      "constructor-word": {
-        // <array> but not <=>
-        pattern: /(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,
-        lookbehind: true,
-        alias: "keyword"
-      },
-      "other-builtin-syntax": {
-        pattern: null,
-        lookbehind: true,
-        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: true,
-        alias: "keyword"
-      },
-      "colon-syntax": {
-        pattern: /(^|\s)(?:[A-Z0-9\-]+#?)?:{1,2}\s+(?:;\S+|(?!;)\S+)(?=\s|$)/,
-        lookbehind: true,
-        greedy: true,
-        alias: "function"
-      },
-      "semicolon-or-setlocal": {
-        pattern: /(\s)(?:;|:>)(?=\s|$)/,
-        lookbehind: true,
-        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: true,
-          alias: "operator"
-        },
-        {
-          // closing
-          pattern: /(\s)\}(?=\s|$)/,
-          lookbehind: true,
-          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: true,
-          alias: "operator"
-        },
-        {
-          // closing
-          pattern: /(\s)\](?=\s|$)/,
-          lookbehind: true,
-          alias: "operator"
-        }
-      ],
-      "normal-word": {
-        pattern: /(^|\s)[^"\s]\S*(?=\s|$)/,
-        lookbehind: true
-      },
-      /*
-      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: true,
-        inside: string_inside
-      }
-    };
-    var escape = function(str) {
-      return (str + "").replace(/([.?*+\^$\[\]\\(){}|\-])/g, "\\$1");
-    };
-    var arrToWordsRegExp = function(arr) {
-      return new RegExp("(^|\\s)(?:" + arr.map(escape).join("|") + ")(?=\\s|$)");
-    };
-    var builtins = {
-      "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(builtins).forEach(function(k) {
-      factor2[k].pattern = arrToWordsRegExp(builtins[k]);
-    });
-    var combinators = [
-      // 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
-    ];
-    factor2.combinators.pattern = arrToWordsRegExp(combinators);
-    Prism2.languages.factor = factor2;
-  })(Prism);
-}
-
-export {
-  factor
-};