feat: Fluent UI Outlook Lite + connections mockup

node_modules/@swc/helpers/esm/_wrap_reg_exp.js

@@ -0,0 +1,82 @@
+import { _ as _inherits } from "./_inherits.js";
+import { _ as _set_prototype_of } from "./_set_prototype_of.js";
+
+function _wrap_reg_exp(re, groups, source) {
+    _wrap_reg_exp = function(re, groups, source) {
+        return new WrappedRegExp(re, undefined, groups, source);
+    };
+    var _super = RegExp.prototype;
+    var _groups = new WeakMap();
+    var _sources = new WeakMap();
+    var _native_source = Object.getOwnPropertyDescriptor(_super, "source").get;
+    function WrappedRegExp(re, flags, groups, source) {
+        var _re = new RegExp(re, flags);
+        _groups.set(_re, groups || _groups.get(re));
+        _sources.set(_re, source !== undefined ? source : _sources.get(re));
+        return _set_prototype_of(_re, WrappedRegExp.prototype);
+    }
+    _inherits(WrappedRegExp, RegExp);
+    Object.defineProperty(WrappedRegExp.prototype, "source", {
+        configurable: true,
+        get: function() {
+            var source = _sources.get(this);
+            if (source !== undefined) {
+                try {
+                    new RegExp(source, this.flags);
+                    return source;
+                } catch (_) {}
+            }
+            return _native_source.call(this);
+        }
+    });
+    WrappedRegExp.prototype.exec = function(str) {
+        var result = _super.exec.call(this, str);
+        if (result) {
+            result.groups = buildGroups(result, this);
+            var indices = result.indices;
+            if (indices) indices.groups = buildGroups(indices, this);
+        }
+        return result;
+    };
+    WrappedRegExp.prototype[Symbol.replace] = function(str, substitution) {
+        if (typeof substitution === "string") {
+            var groups = _groups.get(this);
+            return _super[Symbol.replace].call(
+                this,
+                str,
+                substitution.replace(/\$<([^>]+)>/g, function(_, name) {
+                    var group = groups ? groups[name] : undefined;
+                    if (group === undefined) return "";
+                    return "$" + (Array.isArray(group) ? group.join("$") : group);
+                })
+            );
+        }
+        if (typeof substitution === "function") {
+            var _this = this;
+            return _super[Symbol.replace].call(this, str, function() {
+                var args = arguments;
+                if (typeof args[args.length - 1] !== "object") {
+                    args = [].slice.call(args);
+                    args.push(buildGroups(args, _this));
+                }
+                return substitution.apply(this, args);
+            });
+        }
+        return _super[Symbol.replace].call(this, str, substitution);
+    };
+    function buildGroups(result, re) {
+        var g = _groups.get(re);
+        return Object.keys(g).reduce(function(groups, name) {
+            var i = g[name];
+            if (typeof i === "number") groups[name] = result[i];
+            else {
+                var k = 0;
+                while (result[i[k]] === undefined && k + 1 < i.length) k++;
+                groups[name] = result[i[k]];
+            }
+            return groups;
+        }, Object.create(null));
+    }
+    return _wrap_reg_exp.apply(this, arguments);
+}
+export { _wrap_reg_exp as _ };