jslike 1.3.1 → 1.4.0

package/dist/editor/monaco/index.js

@@ -0,0 +1,214 @@
+// src/editor/monaco/index.js
+var wangLanguage = {
+  defaultToken: "invalid",
+  tokenPostfix: ".wang",
+  keywords: [
+    "let",
+    "const",
+    "var",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "break",
+    "continue",
+    "return",
+    "function",
+    "class",
+    "extends",
+    "constructor",
+    "async",
+    "await",
+    "import",
+    "export",
+    "from",
+    "as",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "this",
+    "super",
+    "new",
+    "typeof",
+    "instanceof",
+    "in",
+    "of"
+  ],
+  typeKeywords: [],
+  operators: [
+    "=>",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "===",
+    "!==",
+    "==",
+    "!=",
+    "<=",
+    ">=",
+    "<<",
+    ">>",
+    ">>>",
+    "&&",
+    "||",
+    "??",
+    "?.",
+    "...",
+    "++",
+    "--",
+    "**",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "&",
+    "|",
+    "^",
+    "~",
+    "!",
+    "?",
+    ":",
+    "=",
+    "<",
+    ">"
+  ],
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  tokenizer: {
+    root: [
+      // Identifiers and keywords
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "true|false|null|undefined": "constant",
+            "@default": "identifier"
+          }
+        }
+      ],
+      // Whitespace
+      { include: "@whitespace" },
+      // Delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "operator",
+            "@default": ""
+          }
+        }
+      ],
+      // Numbers
+      [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F]+/, "number.hex"],
+      [/\d+/, "number"],
+      // Delimiter
+      [/[;,.]/, "delimiter"],
+      // Strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      [/"/, "string", "@string_double"],
+      [/'/, "string", "@string_single"],
+      // Template literals
+      [/`/, "string.template", "@template"],
+      // Regular expressions
+      [/\/(?=([^\/\\]|\\.)+\/)/, "regexp", "@regexp"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    string_double: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    string_single: [
+      [/[^\\']+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, "string", "@pop"]
+    ],
+    template: [
+      [/[^`\\$]+/, "string.template"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/\${/, { token: "delimiter.bracket", next: "@templateExpression" }],
+      [/`/, "string.template", "@pop"]
+    ],
+    templateExpression: [[/}/, { token: "delimiter.bracket", next: "@pop" }], { include: "root" }],
+    regexp: [
+      [
+        /(\{)(\d+(?:,\d*)?)(\})/,
+        ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]
+      ],
+      [/(\[)([^\]\\]|\\.)*(\])/, "regexp.escape.control"],
+      [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+      [/[()]/, "regexp.escape.control"],
+      [/@escapes/, "regexp.escape"],
+      [/\\./, "regexp.escape"],
+      [/\/[gimsuy]*/, { token: "regexp", bracket: "@close", next: "@pop" }],
+      [/./, "regexp"]
+    ]
+  }
+};
+function registerWangLanguage(monaco) {
+  monaco.languages.register({ id: "wang" });
+  monaco.languages.setMonarchTokensProvider("wang", wangLanguage);
+  monaco.languages.setLanguageConfiguration("wang", {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string"] },
+      { open: "`", close: "`", notIn: ["string"] },
+      { open: "/*", close: "*/" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*#?region\\b"),
+        end: new RegExp("^\\s*//\\s*#?endregion\\b")
+      }
+    },
+    indentationRules: {
+      increaseIndentPattern: new RegExp("^.*(\\{[^}]*|\\([^)]*|\\[[^\\]]*)$"),
+      decreaseIndentPattern: new RegExp("^\\s*(\\}|\\)|\\])")
+    }
+  });
+}
+export {
+  registerWangLanguage,
+  wangLanguage
+};

package/dist/editor/wang-prism.cjs

@@ -0,0 +1,109 @@
+// src/editor/wang-prism.js
+(function(Prism2) {
+  Prism2.languages.wang = {
+    // Comments
+    comment: [
+      {
+        pattern: /\/\*[\s\S]*?\*\//,
+        greedy: true
+      },
+      {
+        pattern: /\/\/.*/,
+        greedy: true
+      }
+    ],
+    // Template literals with interpolation
+    "template-string": {
+      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+      greedy: true,
+      inside: {
+        "template-punctuation": {
+          pattern: /^`|`$/,
+          alias: "string"
+        },
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+          lookbehind: true,
+          inside: {
+            "interpolation-punctuation": {
+              pattern: /^\$\{|\}$/,
+              alias: "punctuation"
+            },
+            rest: Prism2.languages.wang
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    // Strings
+    string: [
+      {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      }
+    ],
+    // Regular expressions
+    regex: {
+      pattern: /\/(?:\\.|[^\/\\\r\n])+\/[gimsuy]*/,
+      greedy: true,
+      inside: {
+        "regex-delimiter": {
+          pattern: /^\/|\/[gimsuy]*$/,
+          alias: "punctuation"
+        },
+        "regex-flags": {
+          pattern: /[gimsuy]+$/,
+          alias: "keyword"
+        }
+      }
+    },
+    // Keywords
+    keyword: /\b(?:let|const|var|if|else|for|while|do|break|continue|return|function|class|extends|constructor|async|await|import|export|from|as|try|catch|finally|throw|new|this|super|typeof|instanceof|in|of)\b/,
+    // Boolean and null values
+    boolean: /\b(?:true|false)\b/,
+    null: /\b(?:null|undefined)\b/,
+    // Numbers
+    number: /\b(?:0x[\dA-Fa-f]+|0b[01]+|0o[0-7]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+    // Arrow function operator
+    "arrow-operator": {
+      pattern: /=>/,
+      alias: "operator"
+    },
+    // Operators (order matters for matching)
+    operator: /\+\+|--|===|!==|==|!=|<=|>=|<<|>>>|>>|&&|\|\||[?]{2}|\?\.|\.{3}|\*\*|\+=|-=|\*=|\/=|[+\-*/%<>&|^~!?:]=?/,
+    // Punctuation
+    punctuation: /[{}[\];(),.:]/,
+    // Functions (pattern for function calls)
+    function: /\b[a-zA-Z_$][\w$]*(?=\s*\()/,
+    // Class names (after class or extends)
+    "class-name": {
+      pattern: /(\b(?:class|extends)\s+)[a-zA-Z_$][\w$]*/,
+      lookbehind: true
+    },
+    // Property names in object literals
+    property: {
+      pattern: /((?:^|[,{])[ \t]*)(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*|"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*')(?=\s*:)/m,
+      lookbehind: true,
+      greedy: true
+    },
+    // Variables and identifiers (must come last)
+    variable: /\b[a-zA-Z_$][\w$]*/
+  };
+  Prism2.languages.wang["class-name"].pattern = /(\b(?:class|extends|new)\s+)[a-zA-Z_$][\w$]*/;
+  Prism2.hooks.add("before-tokenize", function(env) {
+    if (env.language !== "wang") {
+      return;
+    }
+  });
+  Prism2.hooks.add("wrap", function(env) {
+    if (env.language !== "wang") {
+      return;
+    }
+    if (env.type === "keyword" && ["import", "export", "from", "as"].includes(env.content)) {
+      env.classes.push("wang-module");
+    }
+  });
+})(Prism);
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = Prism.languages.wang;
+}

package/dist/editor/wang-prism.d.ts

@@ -0,0 +1,136 @@
+// Wang Language Definition for Prism.js
+/* global Prism */
+(function (Prism) {
+  Prism.languages.wang = {
+    // Comments
+    comment: [
+      {
+        pattern: /\/\*[\s\S]*?\*\//,
+        greedy: true,
+      },
+      {
+        pattern: /\/\/.*/,
+        greedy: true,
+      },
+    ],
+
+    // Template literals with interpolation
+    'template-string': {
+      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+      greedy: true,
+      inside: {
+        'template-punctuation': {
+          pattern: /^`|`$/,
+          alias: 'string',
+        },
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+          lookbehind: true,
+          inside: {
+            'interpolation-punctuation': {
+              pattern: /^\$\{|\}$/,
+              alias: 'punctuation',
+            },
+            rest: Prism.languages.wang,
+          },
+        },
+        string: /[\s\S]+/,
+      },
+    },
+
+    // Strings
+    string: [
+      {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true,
+      },
+    ],
+
+    // Regular expressions
+    regex: {
+      pattern: /\/(?:\\.|[^\/\\\r\n])+\/[gimsuy]*/,
+      greedy: true,
+      inside: {
+        'regex-delimiter': {
+          pattern: /^\/|\/[gimsuy]*$/,
+          alias: 'punctuation',
+        },
+        'regex-flags': {
+          pattern: /[gimsuy]+$/,
+          alias: 'keyword',
+        },
+      },
+    },
+
+    // Keywords
+    keyword:
+      /\b(?:let|const|var|if|else|for|while|do|break|continue|return|function|class|extends|constructor|async|await|import|export|from|as|try|catch|finally|throw|new|this|super|typeof|instanceof|in|of)\b/,
+
+    // Boolean and null values
+    boolean: /\b(?:true|false)\b/,
+    null: /\b(?:null|undefined)\b/,
+
+    // Numbers
+    number: /\b(?:0x[\dA-Fa-f]+|0b[01]+|0o[0-7]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+
+    // Arrow function operator
+    'arrow-operator': {
+      pattern: /=>/,
+      alias: 'operator',
+    },
+
+    // Operators (order matters for matching)
+    operator:
+      /\+\+|--|===|!==|==|!=|<=|>=|<<|>>>|>>|&&|\|\||[?]{2}|\?\.|\.{3}|\*\*|\+=|-=|\*=|\/=|[+\-*/%<>&|^~!?:]=?/,
+
+    // Punctuation
+    punctuation: /[{}[\];(),.:]/,
+
+    // Functions (pattern for function calls)
+    function: /\b[a-zA-Z_$][\w$]*(?=\s*\()/,
+
+    // Class names (after class or extends)
+    'class-name': {
+      pattern: /(\b(?:class|extends)\s+)[a-zA-Z_$][\w$]*/,
+      lookbehind: true,
+    },
+
+    // Property names in object literals
+    property: {
+      pattern:
+        /((?:^|[,{])[ \t]*)(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*|"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*')(?=\s*:)/m,
+      lookbehind: true,
+      greedy: true,
+    },
+
+    // Variables and identifiers (must come last)
+    variable: /\b[a-zA-Z_$][\w$]*/,
+  };
+
+  // Set wang as an alias for javascript-like highlighting
+  Prism.languages.wang['class-name'].pattern = /(\b(?:class|extends|new)\s+)[a-zA-Z_$][\w$]*/;
+
+  // Hook to handle special Wang syntax
+  Prism.hooks.add('before-tokenize', function (env) {
+    if (env.language !== 'wang') {
+      return;
+    }
+  });
+
+  // Hook to add special classes for Wang-specific features
+  Prism.hooks.add('wrap', function (env) {
+    if (env.language !== 'wang') {
+      return;
+    }
+
+    // Add special class for Wang keywords
+    if (env.type === 'keyword' && ['import', 'export', 'from', 'as'].includes(env.content)) {
+      env.classes.push('wang-module');
+    }
+  });
+})(Prism);
+
+// Export for module systems
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = Prism.languages.wang;
+}

package/dist/editor/wang-prism.js

@@ -0,0 +1,109 @@
+// src/editor/wang-prism.js
+(function(Prism2) {
+  Prism2.languages.wang = {
+    // Comments
+    comment: [
+      {
+        pattern: /\/\*[\s\S]*?\*\//,
+        greedy: true
+      },
+      {
+        pattern: /\/\/.*/,
+        greedy: true
+      }
+    ],
+    // Template literals with interpolation
+    "template-string": {
+      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+      greedy: true,
+      inside: {
+        "template-punctuation": {
+          pattern: /^`|`$/,
+          alias: "string"
+        },
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+          lookbehind: true,
+          inside: {
+            "interpolation-punctuation": {
+              pattern: /^\$\{|\}$/,
+              alias: "punctuation"
+            },
+            rest: Prism2.languages.wang
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    // Strings
+    string: [
+      {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      }
+    ],
+    // Regular expressions
+    regex: {
+      pattern: /\/(?:\\.|[^\/\\\r\n])+\/[gimsuy]*/,
+      greedy: true,
+      inside: {
+        "regex-delimiter": {
+          pattern: /^\/|\/[gimsuy]*$/,
+          alias: "punctuation"
+        },
+        "regex-flags": {
+          pattern: /[gimsuy]+$/,
+          alias: "keyword"
+        }
+      }
+    },
+    // Keywords
+    keyword: /\b(?:let|const|var|if|else|for|while|do|break|continue|return|function|class|extends|constructor|async|await|import|export|from|as|try|catch|finally|throw|new|this|super|typeof|instanceof|in|of)\b/,
+    // Boolean and null values
+    boolean: /\b(?:true|false)\b/,
+    null: /\b(?:null|undefined)\b/,
+    // Numbers
+    number: /\b(?:0x[\dA-Fa-f]+|0b[01]+|0o[0-7]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+    // Arrow function operator
+    "arrow-operator": {
+      pattern: /=>/,
+      alias: "operator"
+    },
+    // Operators (order matters for matching)
+    operator: /\+\+|--|===|!==|==|!=|<=|>=|<<|>>>|>>|&&|\|\||[?]{2}|\?\.|\.{3}|\*\*|\+=|-=|\*=|\/=|[+\-*/%<>&|^~!?:]=?/,
+    // Punctuation
+    punctuation: /[{}[\];(),.:]/,
+    // Functions (pattern for function calls)
+    function: /\b[a-zA-Z_$][\w$]*(?=\s*\()/,
+    // Class names (after class or extends)
+    "class-name": {
+      pattern: /(\b(?:class|extends)\s+)[a-zA-Z_$][\w$]*/,
+      lookbehind: true
+    },
+    // Property names in object literals
+    property: {
+      pattern: /((?:^|[,{])[ \t]*)(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*|"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*')(?=\s*:)/m,
+      lookbehind: true,
+      greedy: true
+    },
+    // Variables and identifiers (must come last)
+    variable: /\b[a-zA-Z_$][\w$]*/
+  };
+  Prism2.languages.wang["class-name"].pattern = /(\b(?:class|extends|new)\s+)[a-zA-Z_$][\w$]*/;
+  Prism2.hooks.add("before-tokenize", function(env) {
+    if (env.language !== "wang") {
+      return;
+    }
+  });
+  Prism2.hooks.add("wrap", function(env) {
+    if (env.language !== "wang") {
+      return;
+    }
+    if (env.type === "keyword" && ["import", "export", "from", "as"].includes(env.content)) {
+      env.classes.push("wang-module");
+    }
+  });
+})(Prism);
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = Prism.languages.wang;
+}