@readme/syntax-highlighter 15.0.2 → 16.0.0

package/src/utils/modes/solidity.js

@@ -1,605 +0,0 @@
-// oxlint-disable react/no-this-in-sfc
-// oxlint-disable unicorn/consistent-function-scoping
-// oxlint-disable curly
-// oxlint-disable no-param-reassign
-// oxlint-disable typescript/no-require-imports
-// oxlint-disable func-names
-// oxlint-disable operator-assignment
-// oxlint-disable prefer-arrow-callback
-// oxlint-disable prefer-template
-// oxlint-disable no-return-assign
-// oxlint-disable no-unused-expressions
-// oxlint-disable no-prototype-builtins
-// oxlint-disable no-useless-escape
-// oxlint-disable eqeqeq
-// oxlint-disable global-require
-
-/**
- * This mode has been adapted from the source of `codemirror-solidity` as the way that library is
- * structured makes it impossible for us load as an isolated mode for our Codemirror needs. The
- * source is mostly presented as-is with the exception of a few areas adapted into to our coding
- * standards (such as using `const` instead of `let` for immutable data).
- *
- * @license MIT
- * @see {@link https://github.com/alincode/codemirror-solidity}
- */
-(function (mod) {
-  if (typeof exports === 'object' && typeof module === 'object') {
-    // CommonJS
-    mod(require('codemirror/lib/codemirror'));
-
-    // oxlint-disable-next-line no-undef
-  } else if (typeof define === 'function' && define.amd) {
-    // AMD
-    // oxlint-disable-next-line no-undef
-    define(['codemirror/lib/codemirror'], mod);
-  } else {
-    // Plain browser env
-    // oxlint-disable-next-line no-undef
-    mod(CodeMirror);
-  }
-})(function (CodeMirror) {
-  CodeMirror.defineMode('solidity', function (config) {
-    const indentUnit = config.indentUnit;
-
-    // let functionKeyword = 'function'
-    // let functionNameKeyword = 'Name'
-    // let leftBracketSign = '('
-    // let rightBracketSign = ')'
-    // let functionVariableName = 'variable'
-    // let keyWordContract = 'contract'
-
-    const keywords = {
-      pragma: true,
-      solidity: true,
-      import: true,
-      as: true,
-      from: true,
-      contract: true,
-      constructor: true,
-      is: true,
-      function: true,
-      modifier: true,
-      // modifiers
-      pure: true,
-      view: true,
-      payable: true,
-      constant: true,
-      anonymous: true,
-      indexed: true,
-      returns: true,
-      return: true,
-      event: true,
-      struct: true,
-      mapping: true,
-      interface: true,
-      using: true,
-      library: true,
-      storage: true,
-      memory: true,
-      calldata: true,
-      public: true,
-      private: true,
-      external: true,
-      internal: true,
-      emit: true,
-      assembly: true,
-      abstract: true,
-      after: true,
-      catch: true,
-      final: true,
-      in: true,
-      inline: true,
-      let: true,
-      match: true,
-      null: true,
-      of: true,
-      relocatable: true,
-      static: true,
-      try: true,
-      typeof: true,
-      var: true,
-    };
-
-    const keywordsSpecial = {
-      pragma: true,
-      returns: true,
-      address: true,
-      contract: true,
-      function: true,
-      struct: true,
-    };
-
-    const keywordsEtherUnit = {
-      wei: true,
-      szabo: true,
-      finney: true,
-      ether: true,
-    };
-    const keywordsTimeUnit = {
-      seconds: true,
-      minutes: true,
-      hours: true,
-      days: true,
-      weeks: true,
-    };
-    const keywordsBlockAndTransactionProperties = {
-      block: ['coinbase', 'difficulty', 'gaslimit', 'number', 'timestamp'],
-      msg: ['data', 'sender', 'sig', 'value'],
-      tx: ['gasprice', 'origin'],
-    };
-    const keywordsMoreBlockAndTransactionProperties = {
-      now: true,
-      gasleft: true,
-      blockhash: true,
-    };
-    const keywordsErrorHandling = {
-      assert: true,
-      require: true,
-      revert: true,
-      throw: true,
-    };
-    const keywordsMathematicalAndCryptographicFuctions = {
-      addmod: true,
-      mulmod: true,
-      keccak256: true,
-      sha256: true,
-      ripemd160: true,
-      ecrecover: true,
-    };
-    const keywordsContractRelated = {
-      this: true,
-      selfdestruct: true,
-      super: true,
-    };
-    const keywordsTypeInformation = { type: true };
-    const keywordsContractList = {};
-
-    const keywordsControlStructures = {
-      if: true,
-      else: true,
-      while: true,
-      do: true,
-      for: true,
-      break: true,
-      continue: true,
-      switch: true,
-      case: true,
-      default: true,
-    };
-
-    const keywordsValueTypes = {
-      bool: true,
-      byte: true,
-      string: true,
-      enum: true,
-      address: true,
-    };
-
-    const keywordsV0505NewReserve = {
-      alias: true,
-      apply: true,
-      auto: true,
-      copyof: true,
-      define: true,
-      immutable: true,
-      implements: true,
-      macro: true,
-      mutable: true,
-      override: true,
-      partial: true,
-      promise: true,
-      reference: true,
-      sealed: true,
-      sizeof: true,
-      supports: true,
-      typedef: true,
-      unchecked: true,
-    };
-
-    const keywordsAbiEncodeDecodeFunctions = {
-      abi: ['decode', 'encodePacked', 'encodeWithSelector', 'encodeWithSignature', 'encode'],
-    };
-
-    const keywordsMembersOfAddressType = ['transfer', 'send', 'balance', 'call', 'delegatecall', 'staticcall'];
-
-    const natSpecTags = ['title', 'author', 'notice', 'dev', 'param', 'return'];
-
-    // let functionStructureStage = [{
-    //   function: ['function', 'returns']
-    // },
-    //   leftBracketSign,
-    //   parameterName,
-    //   parameterValue,
-    //   rightBracketSign,
-    // ];
-
-    const atoms = {
-      delete: true,
-      new: true,
-      true: true,
-      false: true,
-      //  "iota": true, "nil": true, "append": true,
-      // "cap": true, "close": true, "complex": true, "copy": true, "imag": true,
-      // "make": true,  "panic": true, "print": true,
-      // "println": true, "real": true, "recover": true
-    };
-
-    const isOperatorChar = /[+\-*&^%:=<>!|\/~]/;
-    const isNegativeChar = /[-]/;
-
-    let curPunc;
-
-    function tokenBase(stream, state) {
-      let ch = stream.next();
-
-      if (ch == '"' || ch == "'" || ch == '`') {
-        state.tokenize = tokenString(ch);
-        return state.tokenize(stream, state);
-      }
-
-      if (isVersion(stream, state)) return 'version';
-
-      if (
-        ch == '.' &&
-        keywordsMembersOfAddressType.some(function (item) {
-          return stream.match(`${item}`);
-        })
-      )
-        return 'addressFunction';
-
-      if (isNumber(ch, stream)) return 'number';
-
-      if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
-        return updateGarmmer(ch, state);
-      }
-
-      if (ch == '/') {
-        if (stream.eat('*')) {
-          state.tokenize = tokenComment;
-          return tokenComment(stream, state);
-        }
-        if (stream.match(/\/{2}/)) {
-          while ((ch = stream.next())) {
-            if (ch == '@') {
-              stream.backUp(1);
-              state.grammar = 'doc';
-              break;
-            }
-          }
-          return 'doc';
-        }
-
-        if (stream.eat('/')) {
-          stream.skipToEnd();
-          return 'comment';
-        }
-      }
-
-      if (isNegativeChar.test(ch)) {
-        if (isNumber(stream.peek(), stream)) return 'number';
-        return 'operator';
-      }
-
-      if (isOperatorChar.test(ch)) {
-        stream.eatWhile(isOperatorChar);
-        return 'operator';
-      }
-      stream.eatWhile(/[\w\$_\xa1-\uffff]/);
-
-      const cur = stream.current();
-
-      if (state.grammar == 'doc') {
-        if (
-          natSpecTags.some(function (item) {
-            return cur == `@${item}`;
-          })
-        )
-          return 'docReserve';
-        return 'doc';
-      }
-
-      if (cur === 'solidity' && state.lastToken == 'pragma') {
-        state.lastToken = state.lastToken + ' ' + cur;
-      }
-
-      if (keywords.propertyIsEnumerable(cur)) {
-        if (cur == 'case' || cur == 'default') curPunc = 'case';
-        if (keywordsSpecial.propertyIsEnumerable(cur)) state.lastToken = cur;
-        // if (cur == 'function' && state.para == 'parameterMode')
-        return 'keyword';
-      }
-
-      if (keywordsEtherUnit.propertyIsEnumerable(cur)) return 'etherUnit';
-      if (keywordsContractRelated.propertyIsEnumerable(cur)) return 'contractRelated';
-      if (
-        keywordsControlStructures.propertyIsEnumerable(cur) ||
-        keywordsTypeInformation.propertyIsEnumerable(cur) ||
-        keywordsV0505NewReserve.propertyIsEnumerable(cur)
-      )
-        return 'keyword';
-      if (
-        keywordsValueTypes.propertyIsEnumerable(cur) ||
-        keywordsTimeUnit.propertyIsEnumerable(cur) ||
-        isValidInteger(cur) ||
-        isValidBytes(cur) ||
-        isValidFixed(cur)
-      ) {
-        state.lastToken = state.lastToken + 'variable';
-        return 'keyword';
-      }
-
-      if (atoms.propertyIsEnumerable(cur)) return 'atom';
-      if (keywordsErrorHandling.propertyIsEnumerable(cur)) return 'errorHandling';
-      if (keywordsMathematicalAndCryptographicFuctions.propertyIsEnumerable(cur)) return 'mathematicalAndCryptographic';
-
-      if (
-        keywordsMoreBlockAndTransactionProperties.propertyIsEnumerable(cur) ||
-        (keywordsBlockAndTransactionProperties.hasOwnProperty(cur) &&
-          keywordsBlockAndTransactionProperties[cur].some(function (item) {
-            return stream.match(`.${item}`);
-          }))
-      )
-        return 'variable-2';
-
-      if (
-        keywordsAbiEncodeDecodeFunctions.hasOwnProperty(cur) &&
-        keywordsAbiEncodeDecodeFunctions[cur].some(function (item) {
-          return stream.match(`.${item}`);
-        })
-      )
-        return 'abi';
-
-      const style = updateHexLiterals(cur, stream);
-      if (style != null) return style;
-
-      if (
-        (state.lastToken == 'functionName(' || state.lastToken == 'returns(') &&
-        keywordsContractList.propertyIsEnumerable(cur)
-      ) {
-        state.lastToken += 'variable';
-        return 'variable';
-      }
-      if (state.lastToken == 'function') {
-        state.lastToken = 'functionName';
-        if (state.para == null) {
-          state.grammar = 'function';
-          state.para = '';
-        }
-        // state.parasMode = isNaN(state.parasMode) ? 1 : state.functionLayerCount++;
-        state.para += 'functionName';
-        return 'functionName';
-      }
-
-      if (state.lastToken == 'functionName(variable') {
-        state.lastToken = 'functionName(';
-        return 'parameterValue';
-      }
-
-      if (state.lastToken == 'returns(variable') {
-        state.lastToken = 'returns(';
-        return 'parameterValue';
-      }
-
-      if (state.lastToken == 'address' && cur == 'payable') {
-        state.lastToken = 'address payable';
-      }
-      if (state.lastToken == 'contract' || state.lastToken == 'struct') {
-        keywordsContractList[cur] = true;
-        state.lastToken = null;
-      }
-      if (state.grammar == 'function') {
-        return 'parameterValue';
-      }
-
-      return 'variable';
-    }
-
-    function tokenString(quote) {
-      return function (stream, state) {
-        let escaped = false;
-        let next;
-        let end = false;
-        while ((next = stream.next()) != null) {
-          if (next == quote && !escaped) {
-            end = true;
-            break;
-          }
-          escaped = !escaped && quote != '`' && next == '\\';
-        }
-        if (end || !(escaped || quote == '`')) state.tokenize = tokenBase;
-        return 'string';
-      };
-    }
-
-    function tokenComment(stream, state) {
-      let maybeEnd = false;
-      let ch;
-      while ((ch = stream.next())) {
-        if (ch == '/' && maybeEnd) {
-          state.tokenize = tokenBase;
-          break;
-        }
-        maybeEnd = ch == '*';
-      }
-      return 'comment';
-    }
-
-    function isVersion(stream, state) {
-      if (state.lastToken == 'pragma solidity') {
-        state.lastToken = null;
-        return (
-          !state.startOfLine &&
-          (stream.match(/[\^{0}][0-9\.]+/) || stream.match(/[\>\=]+?[\s]*[0-9\.]+[\s]*[\<]?[\s]*[0-9\.]+/))
-        );
-      }
-    }
-
-    function isNumber(ch, stream) {
-      if (/[\d\.]/.test(ch)) {
-        if (ch == '.') {
-          stream.match(/^[0-9]+([eE][\-+]?[0-9]+)?/);
-        } else if (ch == '0') {
-          stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^0[0-7]+/);
-        } else {
-          stream.match(/^[0-9]*\.?[0-9]*([eE][\-+]?[0-9]+)?/);
-        }
-        return true;
-      }
-    }
-
-    function isValidInteger(token) {
-      if (token.match(/^[u]?int/)) {
-        if (token.indexOf('t') + 1 == token.length) return true;
-        const numberPart = token.substr(token.indexOf('t') + 1, token.length);
-        return numberPart % 8 === 0 && numberPart <= 256;
-      }
-    }
-
-    function isValidBytes(token) {
-      if (token.match(/^bytes/)) {
-        if (token.indexOf('s') + 1 == token.length) return true;
-        const bytesPart = token.substr(token.indexOf('s') + 1, token.length);
-        return bytesPart <= 32;
-      }
-    }
-
-    function isValidFixed(token) {
-      if (token.match(/^[u]?fixed([0-9]+x[0-9]+)?/)) {
-        if (token.indexOf('d') + 1 == token.length) return true;
-        const numberPart = token.substr(token.indexOf('d') + 1, token.length).split('x');
-        return numberPart[0] % 8 === 0 && numberPart[0] <= 256 && numberPart[1] <= 80;
-      }
-    }
-
-    function updateHexLiterals(token, stream) {
-      if (token.match(/^hex/) && stream.peek() == '"') {
-        let maybeEnd = false;
-        let ch;
-        let hexValue = '';
-        let stringAfterHex = '';
-        while ((ch = stream.next())) {
-          stringAfterHex += ch;
-          if (ch == '"' && maybeEnd) {
-            hexValue = stringAfterHex.substring(1, stringAfterHex.length - 1);
-            if (hexValue.match(/^[0-9a-fA-F]+$/)) {
-              return 'number';
-            }
-
-            stream.backUp(stringAfterHex.length);
-            break;
-          }
-          maybeEnd = maybeEnd || ch == '"';
-        }
-      }
-    }
-
-    function updateGarmmer(ch, state) {
-      if (ch == ',' && state.para == 'functionName(variable') {
-        state.para = 'functionName(';
-      }
-      if (state.para != null && state.para.startsWith('functionName')) {
-        if (ch == ')') {
-          if (state.para.endsWith('(')) {
-            state.para = state.para.substr(0, state.para.length - 1);
-            if (state.para == 'functionName') state.grammar = '';
-          }
-        } else if (ch == '(') {
-          state.para += ch;
-        }
-      }
-
-      if (ch == '(' && state.lastToken == 'functionName') {
-        state.lastToken += ch;
-      } else if (ch == ')' && state.lastToken == 'functionName(') {
-        state.lastToken = null;
-      } else if (ch == '(' && state.lastToken == 'returns') {
-        state.lastToken += ch;
-      } else if (ch == ')' && (state.lastToken == 'returns(' || state.lastToken == 'returns(variable')) {
-        state.lastToken = null;
-      }
-      if (ch == '(' && state.lastToken == 'address') {
-        state.lastToken += ch;
-      }
-      curPunc = ch;
-      return null;
-    }
-
-    function Context(indented, column, type, align, prev) {
-      this.indented = indented;
-      this.column = column;
-      this.type = type;
-      this.align = align;
-      this.prev = prev;
-    }
-    function pushContext(state, col, type) {
-      return (state.context = new Context(state.indented, col, type, null, state.context));
-    }
-    function popContext(state) {
-      if (!state.context.prev) return;
-      const t = state.context.type;
-      if (t == ')' || t == ']' || t == '}') state.indented = state.context.indented;
-      return (state.context = state.context.prev);
-    }
-
-    // Interface
-    return {
-      startState(basecolumn) {
-        return {
-          tokenize: null,
-          context: new Context((basecolumn || 0) - indentUnit, 0, 'top', false),
-          indented: 0,
-          startOfLine: true,
-        };
-      },
-
-      token(stream, state) {
-        const ctx = state.context;
-        if (stream.sol()) {
-          if (ctx.align == null) ctx.align = false;
-          state.indented = stream.indentation();
-          state.startOfLine = true;
-          if (ctx.type == 'case') ctx.type = '}';
-          if (state.grammar == 'doc') state.grammar = null;
-        }
-        if (stream.eatSpace()) return null;
-        curPunc = null;
-        const style = (state.tokenize || tokenBase)(stream, state);
-
-        if (style == 'comment') return style;
-        if (ctx.align == null) ctx.align = true;
-
-        if (curPunc == '{') pushContext(state, stream.column(), '}');
-        else if (curPunc == '[') pushContext(state, stream.column(), ']');
-        else if (curPunc == '(') pushContext(state, stream.column(), ')');
-        else if (curPunc == 'case') ctx.type = 'case';
-        else if (curPunc == '}' && ctx.type == '}') popContext(state);
-        else if (curPunc == ctx.type) popContext(state);
-        state.startOfLine = false;
-        return style;
-      },
-
-      indent(state, textAfter) {
-        if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;
-        const ctx = state.context;
-        const firstChar = textAfter && textAfter.charAt(0);
-        if (ctx.type == 'case' && /^(?:case|default)\b/.test(textAfter)) {
-          state.context.type = '}';
-          return ctx.indented;
-        }
-        const closing = firstChar == ctx.type;
-        if (ctx.align) return ctx.column + (closing ? 0 : 1);
-        return ctx.indented + (closing ? 0 : indentUnit);
-      },
-
-      electricChars: '{}):',
-      closeBrackets: '()[]{}\'\'""``',
-      fold: 'brace',
-      blockCommentStart: '/*',
-      blockCommentEnd: '*/',
-      lineComment: '//',
-    };
-  });
-
-  CodeMirror.defineMIME('text/x-solidity', 'solidity');
-});

package/src/utils/modes.ts

@@ -1,104 +0,0 @@
-// This is a mapping of languages that we support, but aren't directly loading the mode extension
-// Within `/src/codeMirror/index.jsx` and /src/codeEditor.index.jsx
-//
-// This list also includes a number of language aliases, as because of the way we're using
-// `CodeMirror.runMode` we can't take advantage of its known aliases in the mode extensions that
-// we're loading.
-//
-// There are 2 types of lookup, single and array. e.g. `html` needs to be rendered using
-// `htmlmixed`, but `java`, needs to be rendered using the `clike` mode.
-//
-export const modes = {
-  asp: 'clike',
-  aspx: 'clike',
-  bash: 'shell',
-  c: 'clike',
-  'c#': ['clike', 'text/x-csharp'],
-  'c++': ['clike', 'text/x-c++src'],
-  clj: 'clojure',
-  cljc: 'clojure',
-  cljx: 'clojure',
-  coffeescript: 'javascript',
-  cplusplus: ['clike', 'text/x-c++src'],
-  cpp: ['clike', 'text/x-c++src'],
-  cql: ['sql', 'text/x-cassandra'],
-  cs: ['clike', 'text/x-csharp'],
-  csharp: ['clike', 'text/x-csharp'],
-  curl: 'shell',
-  d: 'd',
-  diff: 'diff',
-  ecmascript: 'javascript',
-  erl: 'erlang',
-  go: ['go', 'text/x-go'],
-  gradle: 'groovy',
-  gql: 'graphql',
-  handlebars: 'htmlmixed',
-  hbs: 'htmlmixed',
-  html: 'htmlmixed',
-  java: ['clike', 'text/x-java'],
-  jl: 'julia',
-  js: 'javascript',
-  jsx: 'jsx',
-  json: ['javascript', 'application/ld+json'],
-  jruby: 'ruby',
-  kotlin: ['clike', 'text/x-kotlin'],
-  kt: ['clike', 'text/x-kotlin'],
-  less: 'css',
-  liquid: 'htmlmixed',
-  lua: 'lua',
-  node: 'javascript',
-  macruby: 'ruby',
-  markdown: 'gfm',
-  md: 'gfm',
-  ml: ['mllike', 'text/x-ocaml'],
-  mssql: ['sql', 'text/x-mssql'],
-  mysql: ['sql', 'text/x-mysql'],
-  objc: ['clike', 'text/x-objectivec'],
-  'objc++': ['clike', 'text/x-objectivec++'],
-  objcpp: ['clike', 'text/x-objectivec++'],
-  objectivec: ['clike', 'text/x-objectivec'],
-  objectivecpp: ['clike', 'text/x-objectivec++'],
-  objectivecplusplus: ['clike', 'text/x-objectivec++'],
-  ocaml: ['mllike', 'text/x-ocaml'],
-  php: ['php', 'text/x-php'],
-  pgsql: ['sql', 'text/x-pgsql'],
-  pl: 'perl',
-  plsql: ['sql', 'text/x-plsql'],
-  postgres: ['sql', 'text/x-pgsql'],
-  postgresql: ['sql', 'text/x-pgsql'],
-  ps1: 'powershell',
-  py: 'python',
-  r: 'r',
-  rake: 'ruby',
-  rb: 'ruby',
-  rbx: 'ruby',
-  rs: 'rust',
-  sass: 'css',
-  scala: ['clike', 'text/x-scala'],
-  scss: 'css',
-  sh: 'shell',
-  sol: 'solidity',
-  solidity: 'solidity',
-  sql: ['sql', 'text/x-sql'],
-  sqlite: ['sql', 'text/x-sqlite'],
-  styl: 'css',
-  stylus: 'css',
-  text: ['null', 'text/plain'],
-  ts: ['javascript', 'text/typescript'],
-  typescript: ['javascript', 'text/typescript'],
-  xhtml: 'htmlmixed',
-  yml: 'yaml',
-  zsh: 'shell',
-} as const;
-
-export function getMode(lang: string): string {
-  let mode: string | readonly [string, string] = lang;
-  if (mode in modes) {
-    mode = modes[mode as keyof typeof modes];
-    if (Array.isArray(mode)) {
-      [, mode] = mode;
-    }
-  }
-
-  return mode as string;
-}