@glodon-aiot/react-components 3.3.0-beta.14 → 3.3.0-beta.17

package/dist/es/node_modules/refractor/lang/gml.mjs

@@ -0,0 +1,19 @@
+var t, i;
+function r() {
+  if (i)
+    return t;
+  i = 1, t = e, e.displayName = "gml", e.aliases = [];
+  function e(o) {
+    o.languages.gamemakerlanguage = o.languages.gml = o.languages.extend("clike", {
+      keyword: /\b(?:break|case|continue|default|do|else|enum|exit|for|globalvar|if|repeat|return|switch|until|var|while)\b/,
+      number: /(?:\b0x[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ulf]{0,4}/i,
+      operator: /--|\+\+|[-+%/=]=?|!=|\*\*?=?|<[<=>]?|>[=>]?|&&?|\^\^?|\|\|?|~|\b(?:and|at|not|or|with|xor)\b/,
+      constant: /\b(?:GM_build_date|GM_version|action_(?:continue|restart|reverse|stop)|all|gamespeed_(?:fps|microseconds)|global|local|noone|other|pi|pointer_(?:invalid|null)|self|timezone_(?:local|utc)|undefined|ev_(?:create|destroy|step|alarm|keyboard|mouse|collision|other|draw|draw_(?:begin|end|post|pre)|keypress|keyrelease|trigger|(?:left|middle|no|right)_button|(?:left|middle|right)_press|(?:left|middle|right)_release|mouse_(?:enter|leave|wheel_down|wheel_up)|global_(?:left|middle|right)_button|global_(?:left|middle|right)_press|global_(?:left|middle|right)_release|joystick(?:1|2)_(?:button1|button2|button3|button4|button5|button6|button7|button8|down|left|right|up)|outside|boundary|game_start|game_end|room_start|room_end|no_more_lives|animation_end|end_of_path|no_more_health|user\d|gui|gui_begin|gui_end|step_(?:begin|end|normal))|vk_(?:alt|anykey|backspace|control|delete|down|end|enter|escape|home|insert|left|nokey|pagedown|pageup|pause|printscreen|return|right|shift|space|tab|up|f\d|numpad\d|add|decimal|divide|lalt|lcontrol|lshift|multiply|ralt|rcontrol|rshift|subtract)|achievement_(?:filter_(?:all_players|favorites_only|friends_only)|friends_info|info|leaderboard_info|our_info|pic_loaded|show_(?:achievement|bank|friend_picker|leaderboard|profile|purchase_prompt|ui)|type_challenge|type_score_challenge)|asset_(?:font|object|path|room|script|shader|sound|sprite|tiles|timeline|unknown)|audio_(?:3d|falloff_(?:exponent_distance|exponent_distance_clamped|inverse_distance|inverse_distance_clamped|linear_distance|linear_distance_clamped|none)|mono|new_system|old_system|stereo)|bm_(?:add|complex|dest_alpha|dest_color|dest_colour|inv_dest_alpha|inv_dest_color|inv_dest_colour|inv_src_alpha|inv_src_color|inv_src_colour|max|normal|one|src_alpha|src_alpha_sat|src_color|src_colour|subtract|zero)|browser_(?:chrome|firefox|ie|ie_mobile|not_a_browser|opera|safari|safari_mobile|tizen|unknown|windows_store)|buffer_(?:bool|f16|f32|f64|fast|fixed|generalerror|grow|invalidtype|network|outofbounds|outofspace|s16|s32|s8|seek_end|seek_relative|seek_start|string|text|u16|u32|u64|u8|vbuffer|wrap)|c_(?:aqua|black|blue|dkgray|fuchsia|gray|green|lime|ltgray|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)|cmpfunc_(?:always|equal|greater|greaterequal|less|lessequal|never|notequal)|cr_(?:appstart|arrow|beam|cross|default|drag|handpoint|hourglass|none|size_all|size_nesw|size_ns|size_nwse|size_we|uparrow)|cull_(?:clockwise|counterclockwise|noculling)|device_(?:emulator|tablet)|device_ios_(?:ipad|ipad_retina|iphone|iphone5|iphone6|iphone6plus|iphone_retina|unknown)|display_(?:landscape|landscape_flipped|portrait|portrait_flipped)|dll_(?:cdecl|cdel|stdcall)|ds_type_(?:grid|list|map|priority|queue|stack)|ef_(?:cloud|ellipse|explosion|firework|flare|rain|ring|smoke|smokeup|snow|spark|star)|fa_(?:archive|bottom|center|directory|hidden|left|middle|readonly|right|sysfile|top|volumeid)|fb_login_(?:default|fallback_to_webview|forcing_safari|forcing_webview|no_fallback_to_webview|use_system_account)|iap_(?:available|canceled|ev_consume|ev_product|ev_purchase|ev_restore|ev_storeload|failed|purchased|refunded|status_available|status_loading|status_processing|status_restoring|status_unavailable|status_uninitialised|storeload_failed|storeload_ok|unavailable)|leaderboard_type_(?:number|time_mins_secs)|lighttype_(?:dir|point)|matrix_(?:projection|view|world)|mb_(?:any|left|middle|none|right)|network_(?:config_(?:connect_timeout|disable_reliable_udp|enable_reliable_udp|use_non_blocking_socket)|socket_(?:bluetooth|tcp|udp)|type_(?:connect|data|disconnect|non_blocking_connect))|of_challenge_(?:lose|tie|win)|os_(?:android|ios|linux|macosx|ps3|ps4|psvita|unknown|uwp|win32|win8native|windows|winphone|xboxone)|phy_debug_render_(?:aabb|collision_pairs|coms|core_shapes|joints|obb|shapes)|phy_joint_(?:anchor_1_x|anchor_1_y|anchor_2_x|anchor_2_y|angle|angle_limits|damping_ratio|frequency|length_1|length_2|lower_angle_limit|max_force|max_length|max_motor_force|max_motor_torque|max_torque|motor_force|motor_speed|motor_torque|reaction_force_x|reaction_force_y|reaction_torque|speed|translation|upper_angle_limit)|phy_particle_data_flag_(?:category|color|colour|position|typeflags|velocity)|phy_particle_flag_(?:colormixing|colourmixing|elastic|powder|spring|tensile|viscous|wall|water|zombie)|phy_particle_group_flag_(?:rigid|solid)|pr_(?:linelist|linestrip|pointlist|trianglefan|trianglelist|trianglestrip)|ps_(?:distr|shape)_(?:diamond|ellipse|gaussian|invgaussian|line|linear|rectangle)|pt_shape_(?:circle|cloud|disk|explosion|flare|line|pixel|ring|smoke|snow|spark|sphere|square|star)|ty_(?:real|string)|gp_(?:face\d|axislh|axislv|axisrh|axisrv|padd|padl|padr|padu|select|shoulderl|shoulderlb|shoulderr|shoulderrb|start|stickl|stickr)|lb_disp_(?:none|numeric|time_ms|time_sec)|lb_sort_(?:ascending|descending|none)|ov_(?:achievements|community|friends|gamegroup|players|settings)|ugc_(?:filetype_(?:community|microtrans)|list_(?:Favorited|Followed|Published|Subscribed|UsedOrPlayed|VotedDown|VotedOn|VotedUp|WillVoteLater)|match_(?:AllGuides|Artwork|Collections|ControllerBindings|IntegratedGuides|Items|Items_Mtx|Items_ReadyToUse|Screenshots|UsableInGame|Videos|WebGuides)|query_(?:AcceptedForGameRankedByAcceptanceDate|CreatedByFriendsRankedByPublicationDate|FavoritedByFriendsRankedByPublicationDate|NotYetRated)|query_RankedBy(?:NumTimesReported|PublicationDate|TextSearch|TotalVotesAsc|Trend|Vote|VotesUp)|result_success|sortorder_CreationOrder(?:Asc|Desc)|sortorder_(?:ForModeration|LastUpdatedDesc|SubscriptionDateDesc|TitleAsc|VoteScoreDesc)|visibility_(?:friends_only|private|public))|vertex_usage_(?:binormal|blendindices|blendweight|color|colour|depth|fog|normal|position|psize|sample|tangent|texcoord|textcoord)|vertex_type_(?:float\d|color|colour|ubyte4)|input_type|layerelementtype_(?:background|instance|oldtilemap|particlesystem|sprite|tile|tilemap|undefined)|se_(?:chorus|compressor|echo|equalizer|flanger|gargle|none|reverb)|text_type|tile_(?:flip|index_mask|mirror|rotate)|(?:obj|rm|scr|spr)\w+)\b/,
+      variable: /\b(?:alarm|application_surface|async_load|background_(?:alpha|blend|color|colour|foreground|height|hspeed|htiled|index|showcolor|showcolour|visible|vspeed|vtiled|width|x|xscale|y|yscale)|bbox_(?:bottom|left|right|top)|browser_(?:height|width)|caption_(?:health|lives|score)|current_(?:day|hour|minute|month|second|time|weekday|year)|cursor_sprite|debug_mode|delta_time|direction|display_aa|error_(?:last|occurred)|event_(?:action|number|object|type)|fps|fps_real|friction|game_(?:display|project|save)_(?:id|name)|gamemaker_(?:pro|registered|version)|gravity|gravity_direction|(?:h|v)speed|health|iap_data|id|image_(?:alpha|angle|blend|depth|index|number|speed|xscale|yscale)|instance_(?:count|id)|keyboard_(?:key|lastchar|lastkey|string)|layer|lives|mask_index|mouse_(?:button|lastbutton|x|y)|object_index|os_(?:browser|device|type|version)|path_(?:endaction|index|orientation|position|positionprevious|scale|speed)|persistent|phy_(?:rotation|(?:col_normal|collision|com|linear_velocity|position|speed)_(?:x|y)|angular_(?:damping|velocity)|position_(?:x|y)previous|speed|linear_damping|bullet|fixed_rotation|active|mass|inertia|dynamic|kinematic|sleeping|collision_points)|pointer_(?:invalid|null)|room|room_(?:caption|first|height|last|persistent|speed|width)|score|secure_mode|show_(?:health|lives|score)|solid|speed|sprite_(?:height|index|width|xoffset|yoffset)|temp_directory|timeline_(?:index|loop|position|running|speed)|transition_(?:color|kind|steps)|undefined|view_(?:angle|current|enabled|(?:h|v)(?:border|speed)|(?:h|w|x|y)port|(?:h|w|x|y)view|object|surface_id|visible)|visible|webgl_enabled|working_directory|(?:x|y)(?:previous|start)|x|y|argument(?:_relitive|_count|\d)|argument|global|local|other|self)\b/
+    });
+  }
+  return t;
+}
+export {
+  r as __require
+};

package/dist/es/node_modules/refractor/lang/gn.mjs

@@ -0,0 +1,55 @@
+var t, r;
+function i() {
+  if (r)
+    return t;
+  r = 1, t = e, e.displayName = "gn", e.aliases = ["gni"];
+  function e(n) {
+    n.languages.gn = {
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      "string-literal": {
+        pattern: /(^|[^\\"])"(?:[^\r\n"\\]|\\.)*"/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[\s\S]*?\}|[a-zA-Z_]\w*|0x[a-fA-F0-9]{2})/,
+            lookbehind: !0,
+            inside: {
+              number: /^\$0x[\s\S]{2}$/,
+              variable: /^\$\w+$/,
+              "interpolation-punctuation": {
+                pattern: /^\$\{|\}$/,
+                alias: "punctuation"
+              },
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: null
+                // see below
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      keyword: /\b(?:else|if)\b/,
+      boolean: /\b(?:false|true)\b/,
+      "builtin-function": {
+        // a few functions get special highlighting to improve readability
+        pattern: /\b(?:assert|defined|foreach|import|pool|print|template|tool|toolchain)(?=\s*\()/i,
+        alias: "keyword"
+      },
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      constant: /\b(?:current_cpu|current_os|current_toolchain|default_toolchain|host_cpu|host_os|root_build_dir|root_gen_dir|root_out_dir|target_cpu|target_gen_dir|target_os|target_out_dir)\b/,
+      number: /-?\b\d+\b/,
+      operator: /[-+!=<>]=?|&&|\|\|/,
+      punctuation: /[(){}[\],.]/
+    }, n.languages.gn["string-literal"].inside.interpolation.inside.expression.inside = n.languages.gn, n.languages.gni = n.languages.gn;
+  }
+  return t;
+}
+export {
+  i as __require
+};

package/dist/es/node_modules/refractor/lang/go-module.mjs

@@ -0,0 +1,34 @@
+var o, u;
+function a() {
+  if (u)
+    return o;
+  u = 1, o = e, e.displayName = "goModule", e.aliases = [];
+  function e(r) {
+    r.languages["go-mod"] = r.languages["go-module"] = {
+      comment: {
+        pattern: /\/\/.*/,
+        greedy: !0
+      },
+      version: {
+        pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
+        lookbehind: !0,
+        alias: "number"
+      },
+      "go-version": {
+        pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
+        lookbehind: !0,
+        alias: "number"
+      },
+      keyword: {
+        pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
+        lookbehind: !0
+      },
+      operator: /=>/,
+      punctuation: /[()[\],]/
+    };
+  }
+  return o;
+}
+export {
+  a as __require
+};

package/dist/es/node_modules/refractor/lang/go.mjs

@@ -0,0 +1,36 @@
+var a, n;
+function t() {
+  if (n)
+    return a;
+  n = 1, a = r, r.displayName = "go", r.aliases = [];
+  function r(e) {
+    e.languages.go = e.languages.extend("clike", {
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
+      boolean: /\b(?:_|false|iota|nil|true)\b/,
+      number: [
+        // binary and octal integers
+        /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+        // hexadecimal integers and floats
+        /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+        // decimal integers and floats
+        /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
+      ],
+      operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
+      builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
+    }), e.languages.insertBefore("go", "string", {
+      char: {
+        pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
+        greedy: !0
+      }
+    }), delete e.languages.go["class-name"];
+  }
+  return a;
+}
+export {
+  t as __require
+};

package/dist/es/node_modules/refractor/lang/graphql.mjs

@@ -0,0 +1,133 @@
+var y, A;
+function z() {
+  if (A)
+    return y;
+  A = 1, y = u, u.displayName = "graphql", u.aliases = [];
+  function u(s) {
+    s.languages.graphql = {
+      comment: /#.*/,
+      description: {
+        pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+        greedy: !0,
+        alias: "string",
+        inside: {
+          "language-markdown": {
+            pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+            lookbehind: !0,
+            inside: s.languages.markdown
+          }
+        }
+      },
+      string: {
+        pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+        greedy: !0
+      },
+      number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      boolean: /\b(?:false|true)\b/,
+      variable: /\$[a-z_]\w*/i,
+      directive: {
+        pattern: /@[a-z_]\w*/i,
+        alias: "function"
+      },
+      "attr-name": {
+        pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+        greedy: !0
+      },
+      "atom-input": {
+        pattern: /\b[A-Z]\w*Input\b/,
+        alias: "class-name"
+      },
+      scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+      constant: /\b[A-Z][A-Z_\d]*\b/,
+      "class-name": {
+        pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+        lookbehind: !0
+      },
+      fragment: {
+        pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      "definition-mutation": {
+        pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      "definition-query": {
+        pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+        lookbehind: !0,
+        alias: "function"
+      },
+      keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+      operator: /[!=|&]|\.{3}/,
+      "property-query": /\w+(?=\s*\()/,
+      object: /\w+(?=\s*\{)/,
+      punctuation: /[!(){}\[\]:=,]/,
+      property: /\w+/
+    }, s.hooks.add("after-tokenize", function(m) {
+      if (m.language !== "graphql")
+        return;
+      var i = m.tokens.filter(function(t) {
+        return typeof t != "string" && t.type !== "comment" && t.type !== "scalar";
+      }), a = 0;
+      function o(t) {
+        return i[a + t];
+      }
+      function h(t, r) {
+        r = r || 0;
+        for (var e = 0; e < t.length; e++) {
+          var n = o(e + r);
+          if (!n || n.type !== t[e])
+            return !1;
+        }
+        return !0;
+      }
+      function v(t, r) {
+        for (var e = 1, n = a; n < i.length; n++) {
+          var _ = i[n], d = _.content;
+          if (_.type === "punctuation" && typeof d == "string") {
+            if (t.test(d))
+              e++;
+            else if (r.test(d) && (e--, e === 0))
+              return n;
+          }
+        }
+        return -1;
+      }
+      function l(t, r) {
+        var e = t.alias;
+        e ? Array.isArray(e) || (t.alias = e = [e]) : t.alias = e = [], e.push(r);
+      }
+      for (; a < i.length; ) {
+        var q = i[a++];
+        if (q.type === "keyword" && q.content === "mutation") {
+          var p = [];
+          if (h(["definition-mutation", "punctuation"]) && o(1).content === "(") {
+            a += 2;
+            var f = v(/^\($/, /^\)$/);
+            if (f === -1)
+              continue;
+            for (; a < f; a++) {
+              var c = o(0);
+              c.type === "variable" && (l(c, "variable-input"), p.push(c.content));
+            }
+            a = f + 1;
+          }
+          if (h(["punctuation", "property-query"]) && o(0).content === "{" && (a++, l(o(0), "property-mutation"), p.length > 0)) {
+            var w = v(/^\{$/, /^\}$/);
+            if (w === -1)
+              continue;
+            for (var b = a; b < w; b++) {
+              var g = i[b];
+              g.type === "variable" && p.indexOf(g.content) >= 0 && l(g, "variable-input");
+            }
+          }
+        }
+      }
+    });
+  }
+  return y;
+}
+export {
+  z as __require
+};

package/dist/es/node_modules/refractor/lang/groovy.mjs

@@ -0,0 +1,58 @@
+var o, i;
+function s() {
+  if (i)
+    return o;
+  i = 1, o = a, a.displayName = "groovy", a.aliases = [];
+  function a(e) {
+    e.languages.groovy = e.languages.extend("clike", {
+      string: [{
+        // https://groovy-lang.org/syntax.html#_dollar_slashy_string
+        pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+        greedy: !0
+      }, {
+        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
+        // simple division (see JS regex), so find a fix maybe?
+        pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      }],
+      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+        lookbehind: !0
+      },
+      punctuation: /\.+|[{}[\];(),:$]/
+    }), e.languages.insertBefore("groovy", "string", {
+      shebang: {
+        pattern: /#!.+/,
+        alias: "comment"
+      }
+    }), e.languages.insertBefore("groovy", "punctuation", {
+      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
+    }), e.languages.insertBefore("groovy", "function", {
+      annotation: {
+        pattern: /(^|[^.])@\w+/,
+        lookbehind: !0,
+        alias: "punctuation"
+      }
+    }), e.hooks.add("wrap", function(t) {
+      if (t.language === "groovy" && t.type === "string") {
+        var n = t.content.value[0];
+        if (n != "'") {
+          var r = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
+          n === "$" && (r = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/), t.content.value = t.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&"), t.content = e.highlight(t.content.value, {
+            expression: {
+              pattern: r,
+              lookbehind: !0,
+              inside: e.languages.groovy
+            }
+          }), t.classes.push(n === "/" ? "regex" : "gstring");
+        }
+      }
+    });
+  }
+  return o;
+}
+export {
+  s as __require
+};

package/dist/es/node_modules/refractor/lang/haml.mjs

@@ -0,0 +1,132 @@
+import { __require as d } from "./ruby.mjs";
+var a, o;
+function c() {
+  if (o)
+    return a;
+  o = 1;
+  var s = d();
+  a = r, r.displayName = "haml", r.aliases = [];
+  function r(i) {
+    i.register(s), function(e) {
+      e.languages.haml = {
+        // Multiline stuff should appear before the rest
+        "multiline-comment": {
+          pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
+          lookbehind: !0,
+          alias: "comment"
+        },
+        "multiline-code": [{
+          pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        }, {
+          pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        }],
+        // See at the end of the file for known filters
+        filter: {
+          pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
+          lookbehind: !0,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "symbol"
+            }
+          }
+        },
+        markup: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
+          lookbehind: !0,
+          inside: e.languages.markup
+        },
+        doctype: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
+          lookbehind: !0
+        },
+        tag: {
+          // Allows for one nested group of braces
+          pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
+          lookbehind: !0,
+          inside: {
+            attributes: [{
+              // Lookbehind tries to prevent interpolations from breaking it all
+              // Allows for one nested group of braces
+              pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
+              lookbehind: !0,
+              inside: e.languages.ruby
+            }, {
+              pattern: /\([^)]+\)/,
+              inside: {
+                "attr-value": {
+                  pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
+                  lookbehind: !0
+                },
+                "attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
+                punctuation: /[=(),]/
+              }
+            }, {
+              pattern: /\[[^\]]+\]/,
+              inside: e.languages.ruby
+            }],
+            punctuation: /[<>]/
+          }
+        },
+        code: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        },
+        // Interpolations in plain text
+        interpolation: {
+          pattern: /#\{[^}]+\}/,
+          inside: {
+            delimiter: {
+              pattern: /^#\{|\}$/,
+              alias: "punctuation"
+            },
+            ruby: {
+              pattern: /[\s\S]+/,
+              inside: e.languages.ruby
+            }
+          }
+        },
+        punctuation: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
+          lookbehind: !0
+        }
+      };
+      for (var g = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+", u = ["css", {
+        filter: "coffee",
+        language: "coffeescript"
+      }, "erb", "javascript", "less", "markdown", "ruby", "scss", "textile"], l = {}, n = 0, p = u.length; n < p; n++) {
+        var t = u[n];
+        t = typeof t == "string" ? {
+          filter: t,
+          language: t
+        } : t, e.languages[t.language] && (l["filter-" + t.filter] = {
+          pattern: RegExp(g.replace("{{filter_name}}", function() {
+            return t.filter;
+          })),
+          lookbehind: !0,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "symbol"
+            },
+            text: {
+              pattern: /[\s\S]+/,
+              alias: [t.language, "language-" + t.language],
+              inside: e.languages[t.language]
+            }
+          }
+        });
+      }
+      e.languages.insertBefore("haml", "filter", l);
+    }(i);
+  }
+  return a;
+}
+export {
+  c as __require
+};

package/dist/es/node_modules/refractor/lang/handlebars.mjs

@@ -0,0 +1,46 @@
+import { __require as i } from "./markup-templating.mjs";
+var r, s;
+function d() {
+  if (s)
+    return r;
+  s = 1;
+  var l = i();
+  r = e, e.displayName = "handlebars", e.aliases = ["hbs"];
+  function e(t) {
+    t.register(l), function(a) {
+      a.languages.handlebars = {
+        comment: /\{\{![\s\S]*?\}\}/,
+        delimiter: {
+          pattern: /^\{\{\{?|\}\}\}?$/,
+          alias: "punctuation"
+        },
+        string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+        boolean: /\b(?:false|true)\b/,
+        block: {
+          pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        brackets: {
+          pattern: /\[[^\]]+\]/,
+          inside: {
+            punctuation: /\[|\]/,
+            variable: /[\s\S]+/
+          }
+        },
+        punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+        variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+      }, a.hooks.add("before-tokenize", function(n) {
+        var u = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
+        a.languages["markup-templating"].buildPlaceholders(n, "handlebars", u);
+      }), a.hooks.add("after-tokenize", function(n) {
+        a.languages["markup-templating"].tokenizePlaceholders(n, "handlebars");
+      }), a.languages.hbs = a.languages.handlebars;
+    }(t);
+  }
+  return r;
+}
+export {
+  d as __require
+};

package/dist/es/node_modules/refractor/lang/haskell.mjs

@@ -0,0 +1,76 @@
+var t, i;
+function r() {
+  if (i)
+    return t;
+  i = 1, t = e, e.displayName = "haskell", e.aliases = ["hs"];
+  function e(a) {
+    a.languages.haskell = {
+      comment: {
+        pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
+        lookbehind: !0
+      },
+      char: {
+        pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
+        alias: "string"
+      },
+      string: {
+        pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
+        greedy: !0
+      },
+      keyword: /\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
+      "import-statement": {
+        // The imported or hidden names are not included in this import
+        // statement. This is because we want to highlight those exactly like
+        // we do for the names in the program.
+        pattern: /(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+        lookbehind: !0,
+        inside: {
+          keyword: /\b(?:as|hiding|import|qualified)\b/,
+          punctuation: /\./
+        }
+      },
+      // These are builtin variables only. Constructors are highlighted later as a constant.
+      builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
+      // decimal integers and floating point numbers | octal integers | hexadecimal integers
+      number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
+      operator: [
+        {
+          // infix operator
+          pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
+          greedy: !0
+        },
+        {
+          // function composition
+          pattern: /(\s)\.(?=\s)/,
+          lookbehind: !0
+        },
+        // Most of this is needed because of the meaning of a single '.'.
+        // If it stands alone freely, it is the function composition.
+        // It may also be a separator between a module name and an identifier => no
+        // operator. If it comes together with other special characters it is an
+        // operator too.
+        //
+        // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
+        /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
+      ],
+      // In Haskell, nearly everything is a variable, do not highlight these.
+      hvariable: {
+        pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      constant: {
+        pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
+        inside: {
+          punctuation: /\./
+        }
+      },
+      punctuation: /[{}[\];(),.:]/
+    }, a.languages.hs = a.languages.haskell;
+  }
+  return t;
+}
+export {
+  r as __require
+};