chore: add prismjs for syntax highlighting

1 files changed, 963 insertions, 0 deletions

diff --git a/public/prism/prism-factor.js b/public/prism/prism-factor.js
new file mode 100644
index 0000000..fdbe1cc
--- /dev/null
+++ b/public/prism/prism-factor.js
@@ -0,0 +1,963 @@
+(function (Prism) {
+  var comment_inside = {
+    function:
+      /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/,
+  };
+  var string_inside = {
+    number: /\\[^\s']|%\w/,
+  };
+
+  var factor = {
+    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) {
+    factor[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
+  ];
+
+  factor.combinators.pattern = arrToWordsRegExp(combinators);
+
+  Prism.languages.factor = factor;
+})(Prism);