chore: add prismjs for syntax highlighting

1 files changed, 745 insertions, 0 deletions

diff --git a/public/prism/prism-factor.min.js b/public/prism/prism-factor.min.js
new file mode 100644
index 0000000..70fb151
--- /dev/null
+++ b/public/prism/prism-factor.min.js
@@ -0,0 +1,745 @@
+!(function (e) {
+  var t = {
+      function:
+        /\b(?:BUGS?|FIX(?:MES?)?|NOTES?|TODOS?|XX+|HACKS?|WARN(?:ING)?|\?{2,}|!{2,})\b/,
+    },
+    s = { number: /\\[^\s']|%\w/ },
+    i = {
+      comment: [
+        { pattern: /(^|\s)(?:! .*|!$)/, lookbehind: !0, inside: t },
+        {
+          pattern: /(^|\s)\/\*\s[\s\S]*?\*\/(?=\s|$)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: t,
+        },
+        {
+          pattern: /(^|\s)!\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: t,
+        },
+      ],
+      number: [
+        { pattern: /(^|\s)[+-]?\d+(?=\s|$)/, lookbehind: !0 },
+        {
+          pattern: /(^|\s)[+-]?0(?:b[01]+|o[0-7]+|d\d+|x[\dA-F]+)(?=\s|$)/i,
+          lookbehind: !0,
+        },
+        { pattern: /(^|\s)[+-]?\d+\/\d+\.?(?=\s|$)/, lookbehind: !0 },
+        { pattern: /(^|\s)\+?\d+\+\d+\/\d+(?=\s|$)/, lookbehind: !0 },
+        { pattern: /(^|\s)-\d+-\d+\/\d+(?=\s|$)/, lookbehind: !0 },
+        {
+          pattern:
+            /(^|\s)[+-]?(?:\d*\.\d+|\d+\.\d*|\d+)(?:e[+-]?\d+)?(?=\s|$)/i,
+          lookbehind: !0,
+        },
+        { pattern: /(^|\s)NAN:\s+[\da-fA-F]+(?=\s|$)/, lookbehind: !0 },
+        {
+          pattern:
+            /(^|\s)[+-]?0(?:b1\.[01]*|o1\.[0-7]*|d1\.\d*|x1\.[\dA-F]*)p\d+(?=\s|$)/i,
+          lookbehind: !0,
+        },
+      ],
+      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 },
+      'custom-string': {
+        pattern: /(^|\s)[A-Z0-9\-]+"\s(?:\\\S|[^"\\])*"/,
+        lookbehind: !0,
+        greedy: !0,
+        alias: 'string',
+        inside: { number: /\\\S|%\w|\// },
+      },
+      'multiline-string': [
+        {
+          pattern: /(^|\s)STRING:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*;(?=\s|$)/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: 'string',
+          inside: {
+            number: s.number,
+            'semicolon-or-setlocal': {
+              pattern: /([\r\n][ \t]*);(?=\s|$)/,
+              lookbehind: !0,
+              alias: 'function',
+            },
+          },
+        },
+        {
+          pattern: /(^|\s)HEREDOC:\s+\S+(?:\n|\r\n).*(?:\n|\r\n)\s*\S+(?=\s|$)/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: 'string',
+          inside: s,
+        },
+        {
+          pattern: /(^|\s)\[(={0,6})\[\s[\s\S]*?\]\2\](?=\s|$)/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: 'string',
+          inside: s,
+        },
+      ],
+      'special-using': {
+        pattern: /(^|\s)USING:(?:\s\S+)*(?=\s+;(?:\s|$))/,
+        lookbehind: !0,
+        alias: 'function',
+        inside: { string: { pattern: /(\s)[^:\s]+/, lookbehind: !0 } },
+      },
+      'stack-effect-delimiter': [
+        {
+          pattern: /(^|\s)(?:call|eval|execute)?\((?=\s)/,
+          lookbehind: !0,
+          alias: 'operator',
+        },
+        { pattern: /(\s)--(?=\s)/, lookbehind: !0, alias: 'operator' },
+        { 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': {
+        pattern: /(^|\s)<(?!=+>|-+>)\S+>(?=\s|$)/,
+        lookbehind: !0,
+        alias: 'keyword',
+      },
+      'other-builtin-syntax': {
+        pattern: null,
+        lookbehind: !0,
+        alias: 'operator',
+      },
+      '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',
+      },
+      'curly-brace-literal-delimiter': [
+        { pattern: /(^|\s)[a-z]*\{(?=\s)/i, lookbehind: !0, alias: 'operator' },
+        { pattern: /(\s)\}(?=\s|$)/, lookbehind: !0, alias: 'operator' },
+      ],
+      'quotation-delimiter': [
+        { pattern: /(^|\s)\[(?=\s)/, lookbehind: !0, alias: 'operator' },
+        { pattern: /(\s)\](?=\s|$)/, lookbehind: !0, alias: 'operator' },
+      ],
+      'normal-word': { pattern: /(^|\s)[^"\s]\S*(?=\s|$)/, lookbehind: !0 },
+      string: { pattern: /"(?:\\\S|[^"\\])*"/, greedy: !0, inside: s },
+    },
+    n = function (e) {
+      return (e + '').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1');
+    },
+    r = function (e) {
+      return new RegExp('(^|\\s)(?:' + e.map(n).join('|') + ')(?=\\s|$)');
+    },
+    a = {
+      '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': [
+        '=======',
+        'recursive',
+        'flushable',
+        '>>',
+        '<<<<<<',
+        'M\\',
+        'B',
+        'PRIVATE>',
+        '\\',
+        '======',
+        'final',
+        'inline',
+        'delimiter',
+        'deprecated',
+        '<PRIVATE',
+        '>>>>>>',
+        '<<<<<<<',
+        'parse-complex',
+        'malformed-complex',
+        'read-only',
+        '>>>>>>>',
+        'call-next-method',
+        '<<',
+        'foldable',
+        '$',
+        '$[',
+        '${',
+      ],
+      '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',
+      ],
+    };
+  Object.keys(a).forEach(function (e) {
+    i[e].pattern = r(a[e]);
+  });
+  (i.combinators.pattern = r([
+    '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@',
+    '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',
+    'if-zero',
+    'each-integer',
+    'unless-zero',
+    '(find-integer)',
+    'when-zero',
+    'find-last-integer',
+    '(all-integers?)',
+    'times',
+    '(each-integer)',
+    'find-integer',
+    'all-integers?',
+    'unless-negative',
+    'if-positive',
+    'when-positive',
+    'when-negative',
+    'unless-positive',
+    'if-negative',
+    'case',
+    '2cleave',
+    'cond>quot',
+    'case>quot',
+    '3cleave',
+    'wrong-values',
+    'to-fixed-point',
+    'alist>quot',
+    'cond',
+    'cleave',
+    'call-effect',
+    'recursive-hashcode',
+    'spread',
+    'deep-spread>quot',
+    '2||',
+    '0||',
+    'n||',
+    '0&&',
+    '2&&',
+    '3||',
+    '1||',
+    '1&&',
+    'n&&',
+    '3&&',
+    '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',
+  ])),
+    (e.languages.factor = i);
+})(Prism);