@distri/react 0.3.2 → 0.3.4

package/dist/chunk-GBJDIK2H.js

@@ -1,942 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/factor.js
-var require_factor = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/factor.js"(exports, module) {
-    module.exports = factor;
-    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
-            },
-            /* from basis/multiline: */
-            {
-              // /* 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 {
-  require_factor
-};