@fluidattacks/design 8.1.0 → 8.2.0

package/dist/node_modules/refractor/lang/powershell.js

@@ -0,0 +1,62 @@
+r.displayName = "powershell";
+r.aliases = [];
+function r(t) {
+  (function(i) {
+    var e = i.languages.powershell = {
+      comment: [
+        {
+          pattern: /(^|[^`])<#[\s\S]*?#>/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^`])#.*/,
+          lookbehind: !0
+        }
+      ],
+      string: [
+        {
+          pattern: /"(?:`[\s\S]|[^`"])*"/,
+          greedy: !0,
+          inside: null
+          // see below
+        },
+        {
+          pattern: /'(?:[^']|'')*'/,
+          greedy: !0
+        }
+      ],
+      // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
+      // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
+      namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+      boolean: /\$(?:false|true)\b/i,
+      variable: /\$\w+\b/,
+      // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
+      // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
+      // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
+      function: [
+        /\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i,
+        /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i
+      ],
+      // per http://technet.microsoft.com/en-us/library/hh847744.aspx
+      keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+      operator: {
+        pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+        lookbehind: !0
+      },
+      punctuation: /[|{}[\];(),.]/
+    };
+    e.string[0].inside = {
+      function: {
+        // Allow for one level of nesting
+        pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+        lookbehind: !0,
+        inside: e
+      },
+      boolean: e.boolean,
+      variable: e.variable
+    };
+  })(t);
+}
+export {
+  r as default
+};

package/dist/node_modules/refractor/lang/python.js

@@ -0,0 +1,68 @@
+t.displayName = "python";
+t.aliases = ["py"];
+function t(e) {
+  e.languages.python = {
+    comment: {
+      pattern: /(^|[^\\])#.*/,
+      lookbehind: !0,
+      greedy: !0
+    },
+    "string-interpolation": {
+      pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+          pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+          lookbehind: !0,
+          inside: {
+            "format-spec": {
+              pattern: /(:)[^:(){}]+(?=\}$)/,
+              lookbehind: !0
+            },
+            "conversion-option": {
+              pattern: /![sra](?=[:}]$)/,
+              alias: "punctuation"
+            },
+            rest: null
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    "triple-quoted-string": {
+      pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+      greedy: !0,
+      alias: "string"
+    },
+    string: {
+      pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+      greedy: !0
+    },
+    function: {
+      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+      lookbehind: !0
+    },
+    "class-name": {
+      pattern: /(\bclass\s+)\w+/i,
+      lookbehind: !0
+    },
+    decorator: {
+      pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+      lookbehind: !0,
+      alias: ["annotation", "punctuation"],
+      inside: {
+        punctuation: /\./
+      }
+    },
+    keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+    builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+    boolean: /\b(?:False|None|True)\b/,
+    number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+    operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+    punctuation: /[{}[\];(),.:]/
+  }, e.languages.python["string-interpolation"].inside.interpolation.inside.rest = e.languages.python, e.languages.py = e.languages.python;
+}
+export {
+  t as default
+};

package/dist/node_modules/refractor/lang/ruby.js

@@ -0,0 +1,179 @@
+import s from "./clike.js";
+a.displayName = "ruby";
+a.aliases = ["rb"];
+function a(t) {
+  t.register(s), (function(e) {
+    e.languages.ruby = e.languages.extend("clike", {
+      comment: {
+        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /[.\\]/
+        }
+      },
+      keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+      operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+      punctuation: /[(){}[\].,;]/
+    }), e.languages.insertBefore("ruby", "operator", {
+      "double-colon": {
+        pattern: /::/,
+        alias: "punctuation"
+      }
+    });
+    var n = {
+      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+      lookbehind: !0,
+      inside: {
+        content: {
+          pattern: /^(#\{)[\s\S]+(?=\}$)/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        },
+        delimiter: {
+          pattern: /^#\{|\}$/,
+          alias: "punctuation"
+        }
+      }
+    };
+    delete e.languages.ruby.function;
+    var r = "(?:" + [
+      /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+      /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
+      /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
+      /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
+      /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
+    ].join("|") + ")", i = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
+    e.languages.insertBefore("ruby", "keyword", {
+      "regex-literal": [
+        {
+          pattern: RegExp(
+            /%r/.source + r + /[egimnosux]{0,6}/.source
+          ),
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            regex: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            regex: /[\s\S]+/
+          }
+        }
+      ],
+      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+      symbol: [
+        {
+          pattern: RegExp(/(^|[^:]):/.source + i),
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: RegExp(
+            /([\r\n{(,][ \t]*)/.source + i + /(?=:(?!:))/.source
+          ),
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      "method-definition": {
+        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+        lookbehind: !0,
+        inside: {
+          function: /\b\w+$/,
+          keyword: /^self\b/,
+          "class-name": /^\w+/,
+          punctuation: /\./
+        }
+      }
+    }), e.languages.insertBefore("ruby", "string", {
+      "string-literal": [
+        {
+          pattern: RegExp(/%[qQiIwWs]?/.source + r),
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+          alias: "heredoc-string",
+          greedy: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+              inside: {
+                symbol: /\b\w+/,
+                punctuation: /^<<[-~]?/
+              }
+            },
+            interpolation: n,
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+          alias: "heredoc-string",
+          greedy: !0,
+          inside: {
+            delimiter: {
+              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+              inside: {
+                symbol: /\b\w+/,
+                punctuation: /^<<[-~]?'|'$/
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      ],
+      "command-literal": [
+        {
+          pattern: RegExp(/%x/.source + r),
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            command: {
+              pattern: /[\s\S]+/,
+              alias: "string"
+            }
+          }
+        },
+        {
+          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+          greedy: !0,
+          inside: {
+            interpolation: n,
+            command: {
+              pattern: /[\s\S]+/,
+              alias: "string"
+            }
+          }
+        }
+      ]
+    }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
+      builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+    }), e.languages.rb = e.languages.ruby;
+  })(t);
+}
+export {
+  a as default
+};

package/dist/node_modules/refractor/lang/scala.js

@@ -0,0 +1,52 @@
+import t from "./java.js";
+a.displayName = "scala";
+a.aliases = [];
+function a(e) {
+  e.register(t), e.languages.scala = e.languages.extend("java", {
+    "triple-quoted-string": {
+      pattern: /"""[\s\S]*?"""/,
+      greedy: !0,
+      alias: "string"
+    },
+    string: {
+      pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      greedy: !0
+    },
+    keyword: /<-|=>|\b(?:abstract|case|catch|class|def|derives|do|else|enum|extends|extension|final|finally|for|forSome|given|if|implicit|import|infix|inline|lazy|match|new|null|object|opaque|open|override|package|private|protected|return|sealed|self|super|this|throw|trait|transparent|try|type|using|val|var|while|with|yield)\b/,
+    number: /\b0x(?:[\da-f]*\.)?[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e\d+)?[dfl]?/i,
+    builtin: /\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\b/,
+    symbol: /'[^\d\s\\]\w*/
+  }), e.languages.insertBefore("scala", "triple-quoted-string", {
+    "string-interpolation": {
+      pattern: /\b[a-z]\w*(?:"""(?:[^$]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*?"""|"(?:[^$"\r\n]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*")/i,
+      greedy: !0,
+      inside: {
+        id: {
+          pattern: /^\w+/,
+          greedy: !0,
+          alias: "function"
+        },
+        escape: {
+          pattern: /\\\$"|\$[$"]/,
+          greedy: !0,
+          alias: "symbol"
+        },
+        interpolation: {
+          pattern: /\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+          greedy: !0,
+          inside: {
+            punctuation: /^\$\{?|\}$/,
+            expression: {
+              pattern: /[\s\S]+/,
+              inside: e.languages.scala
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    }
+  }), delete e.languages.scala["class-name"], delete e.languages.scala.function, delete e.languages.scala.constant;
+}
+export {
+  a as default
+};

package/dist/node_modules/refractor/lang/swift.js

@@ -0,0 +1,126 @@
+t.displayName = "swift";
+t.aliases = [];
+function t(e) {
+  e.languages.swift = {
+    comment: {
+      // Nested comments are supported up to 2 levels
+      pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+      lookbehind: !0,
+      greedy: !0
+    },
+    "string-literal": [
+      // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
+      {
+        pattern: RegExp(
+          /(^|[^"#])/.source + "(?:" + // single-line string
+          /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + // multi-line string
+          /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+            lookbehind: !0,
+            inside: null
+            // see below
+          },
+          "interpolation-punctuation": {
+            pattern: /^\)|\\\($/,
+            alias: "punctuation"
+          },
+          punctuation: /\\(?=[\r\n])/,
+          string: /[\s\S]+/
+        }
+      },
+      {
+        pattern: RegExp(
+          /(^|[^"#])(#+)/.source + "(?:" + // single-line string
+          /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + // multi-line string
+          /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+            lookbehind: !0,
+            inside: null
+            // see below
+          },
+          "interpolation-punctuation": {
+            pattern: /^\)|\\#+\($/,
+            alias: "punctuation"
+          },
+          string: /[\s\S]+/
+        }
+      }
+    ],
+    directive: {
+      // directives with conditions
+      pattern: RegExp(
+        /#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + // This regex is a little complex. It's equivalent to this:
+        //   (?:![ \t]*)?(?:\b\w+\b(?:[ \t]*<round>)?|<round>)(?:[ \t]*(?:&&|\|\|))?
+        // where <round> is a general parentheses expression.
+        /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"
+      ),
+      alias: "property",
+      inside: {
+        "directive-name": /^#\w+/,
+        boolean: /\b(?:false|true)\b/,
+        number: /\b\d+(?:\.\d+)*\b/,
+        operator: /!|&&|\|\||[<>]=?/,
+        punctuation: /[(),]/
+      }
+    },
+    literal: {
+      pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+      alias: "constant"
+    },
+    "other-directive": {
+      pattern: /#\w+\b/,
+      alias: "property"
+    },
+    attribute: {
+      pattern: /@\w+/,
+      alias: "atrule"
+    },
+    "function-definition": {
+      pattern: /(\bfunc\s+)\w+/,
+      lookbehind: !0,
+      alias: "function"
+    },
+    label: {
+      // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
+      pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+      lookbehind: !0,
+      alias: "important"
+    },
+    keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+    boolean: /\b(?:false|true)\b/,
+    nil: {
+      pattern: /\bnil\b/,
+      alias: "constant"
+    },
+    "short-argument": /\$\d+\b/,
+    omit: {
+      pattern: /\b_\b/,
+      alias: "keyword"
+    },
+    number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+    // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
+    "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+    // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+    // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+    // This regex only supports ASCII operators.
+    operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+    punctuation: /[{}[\]();,.:\\]/
+  }, e.languages.swift["string-literal"].forEach(function(n) {
+    n.inside.interpolation.inside = e.languages.swift;
+  });
+}
+export {
+  t as default
+};

package/dist/node_modules/refractor/lang/toml.js

@@ -0,0 +1,60 @@
+t.displayName = "toml";
+t.aliases = [];
+function t(r) {
+  (function(n) {
+    var a = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
+    function e(d) {
+      return d.replace(/__/g, function() {
+        return a;
+      });
+    }
+    n.languages.toml = {
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      table: {
+        pattern: RegExp(
+          e(
+            /(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source
+          ),
+          "m"
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        alias: "class-name"
+      },
+      key: {
+        pattern: RegExp(
+          e(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source),
+          "m"
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      },
+      string: {
+        pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
+        greedy: !0
+      },
+      date: [
+        {
+          // Offset Date-Time, Local Date-Time, Local Date
+          pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
+          alias: "number"
+        },
+        {
+          // Local Time
+          pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
+          alias: "number"
+        }
+      ],
+      number: /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
+      boolean: /\b(?:false|true)\b/,
+      punctuation: /[.,=[\]{}]/
+    };
+  })(r);
+}
+export {
+  t as default
+};

package/dist/node_modules/refractor/lang/typescript.js

@@ -0,0 +1,53 @@
+import s from "./javascript.js";
+n.displayName = "typescript";
+n.aliases = ["ts"];
+function n(a) {
+  a.register(s), (function(e) {
+    e.languages.typescript = e.languages.extend("javascript", {
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: null
+        // see below
+      },
+      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+    }), e.languages.typescript.keyword.push(
+      /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+      // keywords that have to be followed by an identifier
+      /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+      // This is for `import type *, {}`
+      /\btype\b(?=\s*(?:[\{*]|$))/
+    ), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
+    var t = e.languages.extend("typescript", {});
+    delete t["class-name"], e.languages.typescript["class-name"].inside = t, e.languages.insertBefore("typescript", "function", {
+      decorator: {
+        pattern: /@[$\w\xA0-\uFFFF]+/,
+        inside: {
+          at: {
+            pattern: /^@/,
+            alias: "operator"
+          },
+          function: /^[\s\S]+/
+        }
+      },
+      "generic-function": {
+        // e.g. foo<T extends "bar" | "baz">( ...
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+        greedy: !0,
+        inside: {
+          function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+          generic: {
+            pattern: /<[\s\S]+/,
+            // everything after the first <
+            alias: "class-name",
+            inside: t
+          }
+        }
+      }
+    }), e.languages.ts = e.languages.typescript;
+  })(a);
+}
+export {
+  n as default
+};