@jeremytenjo/super-code-generator
Version:
A powerful, fast, and scalable code generator that saves you time
1,376 lines (1,357 loc) • 8.32 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
__markAsModule(target);
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __reExport = (target, module2, desc) => {
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
for (let key of __getOwnPropNames(module2))
if (!__hasOwnProp.call(target, key) && key !== "default")
__defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
}
return target;
};
var __toModule = (module2) => {
return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// node_modules/tslib/tslib.js
var require_tslib = __commonJS({
"node_modules/tslib/tslib.js"(exports, module2) {
var __extends;
var __assign;
var __rest;
var __decorate;
var __param;
var __esDecorate;
var __runInitializers;
var __propKey;
var __setFunctionName;
var __metadata;
var __awaiter;
var __generator;
var __exportStar;
var __values;
var __read;
var __spread;
var __spreadArrays;
var __spreadArray;
var __await;
var __asyncGenerator;
var __asyncDelegator;
var __asyncValues;
var __makeTemplateObject;
var __importStar;
var __importDefault;
var __classPrivateFieldGet;
var __classPrivateFieldSet;
var __classPrivateFieldIn;
var __createBinding;
var __addDisposableResource;
var __disposeResources;
var __rewriteRelativeImportExtension;
(function(factory) {
var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
if (typeof define === "function" && define.amd) {
define("tslib", ["exports"], function(exports2) {
factory(createExporter(root, createExporter(exports2)));
});
} else if (typeof module2 === "object" && typeof module2.exports === "object") {
factory(createExporter(root, createExporter(module2.exports)));
} else {
factory(createExporter(root));
}
function createExporter(exports2, previous) {
if (exports2 !== root) {
if (typeof Object.create === "function") {
Object.defineProperty(exports2, "__esModule", { value: true });
} else {
exports2.__esModule = true;
}
}
return function(id, v) {
return exports2[id] = previous ? previous(id, v) : v;
};
}
})(function(exporter) {
var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
d.__proto__ = b;
} || function(d, b) {
for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p];
};
__extends = function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
__rest = function(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
__decorate = function(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
__param = function(paramIndex, decorator) {
return function(target, key) {
decorator(target, key, paramIndex);
};
};
__esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
function accept(f) {
if (f !== void 0 && typeof f !== "function")
throw new TypeError("Function expected");
return f;
}
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
var _, done = false;
for (var i = decorators.length - 1; i >= 0; i--) {
var context = {};
for (var p in contextIn)
context[p] = p === "access" ? {} : contextIn[p];
for (var p in contextIn.access)
context.access[p] = contextIn.access[p];
context.addInitializer = function(f) {
if (done)
throw new TypeError("Cannot add initializers after decoration has completed");
extraInitializers.push(accept(f || null));
};
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
if (kind === "accessor") {
if (result === void 0)
continue;
if (result === null || typeof result !== "object")
throw new TypeError("Object expected");
if (_ = accept(result.get))
descriptor.get = _;
if (_ = accept(result.set))
descriptor.set = _;
if (_ = accept(result.init))
initializers.unshift(_);
} else if (_ = accept(result)) {
if (kind === "field")
initializers.unshift(_);
else
descriptor[key] = _;
}
}
if (target)
Object.defineProperty(target, contextIn.name, descriptor);
done = true;
};
__runInitializers = function(thisArg, initializers, value) {
var useValue = arguments.length > 2;
for (var i = 0; i < initializers.length; i++) {
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
}
return useValue ? value : void 0;
};
__propKey = function(x) {
return typeof x === "symbol" ? x : "".concat(x);
};
__setFunctionName = function(f, name, prefix) {
if (typeof name === "symbol")
name = name.description ? "[".concat(name.description, "]") : "";
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
__metadata = function(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
};
__awaiter = function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
__generator = function(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1)
throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
__exportStar = function(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
};
__createBinding = Object.create ? function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
o[k2] = m[k];
};
__values = function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function() {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
__read = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
} finally {
if (e)
throw e.error;
}
}
return ar;
};
__spread = function() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
};
__spreadArrays = function() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
__spreadArray = function(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
__await = function(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
};
__asyncGenerator = function(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function awaitReturn(f) {
return function(v) {
return Promise.resolve(v).then(f, reject);
};
}
function verb(n, f) {
if (g[n]) {
i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
if (f)
i[n] = f(i[n]);
}
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f, v) {
if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]);
}
};
__asyncDelegator = function(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function(e) {
throw e;
}), verb("return"), i[Symbol.iterator] = function() {
return this;
}, i;
function verb(n, f) {
i[n] = o[n] ? function(v) {
return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
} : f;
}
};
__asyncValues = function(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i);
function verb(n) {
i[n] = o[n] && function(v) {
return new Promise(function(resolve, reject) {
v = o[n](v), settle(resolve, reject, v.done, v.value);
});
};
}
function settle(resolve, reject, d, v) {
Promise.resolve(v).then(function(v2) {
resolve({ value: v2, done: d });
}, reject);
}
};
__makeTemplateObject = function(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
} else {
cooked.raw = raw;
}
return cooked;
};
var __setModuleDefault = Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
};
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function(o2) {
var ar = [];
for (var k in o2)
if (Object.prototype.hasOwnProperty.call(o2, k))
ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
__importStar = function(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null) {
for (var k = ownKeys(mod), i = 0; i < k.length; i++)
if (k[i] !== "default")
__createBinding(result, mod, k[i]);
}
__setModuleDefault(result, mod);
return result;
};
__importDefault = function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
__classPrivateFieldGet = function(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
__classPrivateFieldSet = function(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
};
__classPrivateFieldIn = function(state, receiver) {
if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
throw new TypeError("Cannot use 'in' operator on non-object");
return typeof state === "function" ? receiver === state : state.has(receiver);
};
__addDisposableResource = function(env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function")
throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose)
throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose)
throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async)
inner = dispose;
}
if (typeof dispose !== "function")
throw new TypeError("Object not disposable.");
if (inner)
dispose = function() {
try {
inner.call(this);
} catch (e) {
return Promise.reject(e);
}
};
env.stack.push({ value, dispose, async });
} else if (async) {
env.stack.push({ async: true });
}
return value;
};
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
__disposeResources = function(env) {
function fail(e) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1)
return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async)
return s |= 2, Promise.resolve(result).then(next, function(e) {
fail(e);
return next();
});
} else
s |= 1;
} catch (e) {
fail(e);
}
}
if (s === 1)
return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError)
throw env.error;
}
return next();
};
__rewriteRelativeImportExtension = function(path4, preserveJsx) {
if (typeof path4 === "string" && /^\.\.?\//.test(path4)) {
return path4.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
});
}
return path4;
};
exporter("__extends", __extends);
exporter("__assign", __assign);
exporter("__rest", __rest);
exporter("__decorate", __decorate);
exporter("__param", __param);
exporter("__esDecorate", __esDecorate);
exporter("__runInitializers", __runInitializers);
exporter("__propKey", __propKey);
exporter("__setFunctionName", __setFunctionName);
exporter("__metadata", __metadata);
exporter("__awaiter", __awaiter);
exporter("__generator", __generator);
exporter("__exportStar", __exportStar);
exporter("__createBinding", __createBinding);
exporter("__values", __values);
exporter("__read", __read);
exporter("__spread", __spread);
exporter("__spreadArrays", __spreadArrays);
exporter("__spreadArray", __spreadArray);
exporter("__await", __await);
exporter("__asyncGenerator", __asyncGenerator);
exporter("__asyncDelegator", __asyncDelegator);
exporter("__asyncValues", __asyncValues);
exporter("__makeTemplateObject", __makeTemplateObject);
exporter("__importStar", __importStar);
exporter("__importDefault", __importDefault);
exporter("__classPrivateFieldGet", __classPrivateFieldGet);
exporter("__classPrivateFieldSet", __classPrivateFieldSet);
exporter("__classPrivateFieldIn", __classPrivateFieldIn);
exporter("__addDisposableResource", __addDisposableResource);
exporter("__disposeResources", __disposeResources);
exporter("__rewriteRelativeImportExtension", __rewriteRelativeImportExtension);
});
}
});
// node_modules/lower-case/dist/index.js
var require_dist = __commonJS({
"node_modules/lower-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.lowerCase = exports.localeLowerCase = void 0;
var SUPPORTED_LOCALE = {
tr: {
regexp: /\u0130|\u0049|\u0049\u0307/g,
map: {
\u0130: "i",
I: "\u0131",
I\u0307: "i"
}
},
az: {
regexp: /\u0130/g,
map: {
\u0130: "i",
I: "\u0131",
I\u0307: "i"
}
},
lt: {
regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
map: {
I: "i\u0307",
J: "j\u0307",
\u012E: "\u012F\u0307",
\u00CC: "i\u0307\u0300",
\u00CD: "i\u0307\u0301",
\u0128: "i\u0307\u0303"
}
}
};
function localeLowerCase(str, locale) {
var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
if (lang)
return lowerCase2(str.replace(lang.regexp, function(m) {
return lang.map[m];
}));
return lowerCase2(str);
}
exports.localeLowerCase = localeLowerCase;
function lowerCase2(str) {
return str.toLowerCase();
}
exports.lowerCase = lowerCase2;
}
});
// node_modules/no-case/dist/index.js
var require_dist2 = __commonJS({
"node_modules/no-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.noCase = void 0;
var lower_case_1 = require_dist();
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
function noCase(input, options) {
if (options === void 0) {
options = {};
}
var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform2 = _c === void 0 ? lower_case_1.lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
var start = 0;
var end = result.length;
while (result.charAt(start) === "\0")
start++;
while (result.charAt(end - 1) === "\0")
end--;
return result.slice(start, end).split("\0").map(transform2).join(delimiter);
}
exports.noCase = noCase;
function replace(input, re, value) {
if (re instanceof RegExp)
return input.replace(re, value);
return re.reduce(function(input2, re2) {
return input2.replace(re2, value);
}, input);
}
}
});
// node_modules/pascal-case/dist/index.js
var require_dist3 = __commonJS({
"node_modules/pascal-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.pascalCase = exports.pascalCaseTransformMerge = exports.pascalCaseTransform = void 0;
var tslib_1 = require_tslib();
var no_case_1 = require_dist2();
function pascalCaseTransform(input, index) {
var firstChar = input.charAt(0);
var lowerChars = input.substr(1).toLowerCase();
if (index > 0 && firstChar >= "0" && firstChar <= "9") {
return "_" + firstChar + lowerChars;
}
return "" + firstChar.toUpperCase() + lowerChars;
}
exports.pascalCaseTransform = pascalCaseTransform;
function pascalCaseTransformMerge(input) {
return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
}
exports.pascalCaseTransformMerge = pascalCaseTransformMerge;
function pascalCase(input, options) {
if (options === void 0) {
options = {};
}
return no_case_1.noCase(input, tslib_1.__assign({ delimiter: "", transform: pascalCaseTransform }, options));
}
exports.pascalCase = pascalCase;
}
});
// node_modules/camel-case/dist/index.js
var require_dist4 = __commonJS({
"node_modules/camel-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.camelCase = exports.camelCaseTransformMerge = exports.camelCaseTransform = void 0;
var tslib_1 = require_tslib();
var pascal_case_1 = require_dist3();
function camelCaseTransform(input, index) {
if (index === 0)
return input.toLowerCase();
return pascal_case_1.pascalCaseTransform(input, index);
}
exports.camelCaseTransform = camelCaseTransform;
function camelCaseTransformMerge(input, index) {
if (index === 0)
return input.toLowerCase();
return pascal_case_1.pascalCaseTransformMerge(input);
}
exports.camelCaseTransformMerge = camelCaseTransformMerge;
function camelCase(input, options) {
if (options === void 0) {
options = {};
}
return pascal_case_1.pascalCase(input, tslib_1.__assign({ transform: camelCaseTransform }, options));
}
exports.camelCase = camelCase;
}
});
// node_modules/upper-case-first/dist/index.js
var require_dist5 = __commonJS({
"node_modules/upper-case-first/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.upperCaseFirst = void 0;
function upperCaseFirst(input) {
return input.charAt(0).toUpperCase() + input.substr(1);
}
exports.upperCaseFirst = upperCaseFirst;
}
});
// node_modules/capital-case/dist/index.js
var require_dist6 = __commonJS({
"node_modules/capital-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.capitalCase = exports.capitalCaseTransform = void 0;
var tslib_1 = require_tslib();
var no_case_1 = require_dist2();
var upper_case_first_1 = require_dist5();
function capitalCaseTransform(input) {
return upper_case_first_1.upperCaseFirst(input.toLowerCase());
}
exports.capitalCaseTransform = capitalCaseTransform;
function capitalCase(input, options) {
if (options === void 0) {
options = {};
}
return no_case_1.noCase(input, tslib_1.__assign({ delimiter: " ", transform: capitalCaseTransform }, options));
}
exports.capitalCase = capitalCase;
}
});
// node_modules/upper-case/dist/index.js
var require_dist7 = __commonJS({
"node_modules/upper-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.upperCase = exports.localeUpperCase = void 0;
var SUPPORTED_LOCALE = {
tr: {
regexp: /[\u0069]/g,
map: {
i: "\u0130"
}
},
az: {
regexp: /[\u0069]/g,
map: {
i: "\u0130"
}
},
lt: {
regexp: /[\u0069\u006A\u012F]\u0307|\u0069\u0307[\u0300\u0301\u0303]/g,
map: {
i\u0307: "I",
j\u0307: "J",
\u012F\u0307: "\u012E",
i\u0307\u0300: "\xCC",
i\u0307\u0301: "\xCD",
i\u0307\u0303: "\u0128"
}
}
};
function localeUpperCase(str, locale) {
var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
if (lang)
return upperCase(str.replace(lang.regexp, function(m) {
return lang.map[m];
}));
return upperCase(str);
}
exports.localeUpperCase = localeUpperCase;
function upperCase(str) {
return str.toUpperCase();
}
exports.upperCase = upperCase;
}
});
// node_modules/constant-case/dist/index.js
var require_dist8 = __commonJS({
"node_modules/constant-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.constantCase = void 0;
var tslib_1 = require_tslib();
var no_case_1 = require_dist2();
var upper_case_1 = require_dist7();
function constantCase(input, options) {
if (options === void 0) {
options = {};
}
return no_case_1.noCase(input, tslib_1.__assign({ delimiter: "_", transform: upper_case_1.upperCase }, options));
}
exports.constantCase = constantCase;
}
});
// node_modules/dot-case/dist/index.js
var require_dist9 = __commonJS({
"node_modules/dot-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dotCase = void 0;
var tslib_1 = require_tslib();
var no_case_1 = require_dist2();
function dotCase(input, options) {
if (options === void 0) {
options = {};
}
return no_case_1.noCase(input, tslib_1.__assign({ delimiter: "." }, options));
}
exports.dotCase = dotCase;
}
});
// node_modules/header-case/dist/index.js
var require_dist10 = __commonJS({
"node_modules/header-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.headerCase = void 0;
var tslib_1 = require_tslib();
var capital_case_1 = require_dist6();
function headerCase(input, options) {
if (options === void 0) {
options = {};
}
return capital_case_1.capitalCase(input, tslib_1.__assign({ delimiter: "-" }, options));
}
exports.headerCase = headerCase;
}
});
// node_modules/param-case/dist/index.js
var require_dist11 = __commonJS({
"node_modules/param-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.paramCase = void 0;
var tslib_1 = require_tslib();
var dot_case_1 = require_dist9();
function paramCase(input, options) {
if (options === void 0) {
options = {};
}
return dot_case_1.dotCase(input, tslib_1.__assign({ delimiter: "-" }, options));
}
exports.paramCase = paramCase;
}
});
// node_modules/path-case/dist/index.js
var require_dist12 = __commonJS({
"node_modules/path-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.pathCase = void 0;
var tslib_1 = require_tslib();
var dot_case_1 = require_dist9();
function pathCase(input, options) {
if (options === void 0) {
options = {};
}
return dot_case_1.dotCase(input, tslib_1.__assign({ delimiter: "/" }, options));
}
exports.pathCase = pathCase;
}
});
// node_modules/sentence-case/dist/index.js
var require_dist13 = __commonJS({
"node_modules/sentence-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sentenceCase = exports.sentenceCaseTransform = void 0;
var tslib_1 = require_tslib();
var no_case_1 = require_dist2();
var upper_case_first_1 = require_dist5();
function sentenceCaseTransform(input, index) {
var result = input.toLowerCase();
if (index === 0)
return upper_case_first_1.upperCaseFirst(result);
return result;
}
exports.sentenceCaseTransform = sentenceCaseTransform;
function sentenceCase(input, options) {
if (options === void 0) {
options = {};
}
return no_case_1.noCase(input, tslib_1.__assign({ delimiter: " ", transform: sentenceCaseTransform }, options));
}
exports.sentenceCase = sentenceCase;
}
});
// node_modules/snake-case/dist/index.js
var require_dist14 = __commonJS({
"node_modules/snake-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.snakeCase = void 0;
var tslib_1 = require_tslib();
var dot_case_1 = require_dist9();
function snakeCase(input, options) {
if (options === void 0) {
options = {};
}
return dot_case_1.dotCase(input, tslib_1.__assign({ delimiter: "_" }, options));
}
exports.snakeCase = snakeCase;
}
});
// node_modules/change-case/dist/index.js
var require_dist15 = __commonJS({
"node_modules/change-case/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require_tslib();
tslib_1.__exportStar(require_dist4(), exports);
tslib_1.__exportStar(require_dist6(), exports);
tslib_1.__exportStar(require_dist8(), exports);
tslib_1.__exportStar(require_dist9(), exports);
tslib_1.__exportStar(require_dist10(), exports);
tslib_1.__exportStar(require_dist2(), exports);
tslib_1.__exportStar(require_dist11(), exports);
tslib_1.__exportStar(require_dist3(), exports);
tslib_1.__exportStar(require_dist12(), exports);
tslib_1.__exportStar(require_dist13(), exports);
tslib_1.__exportStar(require_dist14(), exports);
}
});
// node_modules/prettier/package.json
var require_package = __commonJS({
"node_modules/prettier/package.json"(exports, module2) {
module2.exports = {
name: "prettier",
version: "2.8.8",
description: "Prettier is an opinionated code formatter",
bin: "./bin-prettier.js",
repository: "prettier/prettier",
funding: "https://github.com/prettier/prettier?sponsor=1",
homepage: "https://prettier.io",
author: "James Long",
license: "MIT",
main: "./index.js",
browser: "./standalone.js",
unpkg: "./standalone.js",
engines: {
node: ">=10.13.0"
},
files: [
"*.js",
"esm/*.mjs"
]
};
}
});
// node_modules/prettier/doc.js
var require_doc = __commonJS({
"node_modules/prettier/doc.js"(exports, module2) {
(function(factory) {
if (typeof exports === "object" && typeof module2 === "object") {
module2.exports = factory();
} else if (typeof define === "function" && define.amd) {
define(factory);
} else {
var root = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : this || {};
root.doc = factory();
}
})(function() {
"use strict";
var __getOwnPropNames2 = Object.getOwnPropertyNames;
var __commonJS2 = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var require_doc_js_umd = __commonJS2({
"dist/_doc.js.umd.js"(exports2, module3) {
var __create2 = Object.create;
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22 = Object.getOwnPropertyNames;
var __getProtoOf2 = Object.getPrototypeOf;
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames22(fn)[0]])(fn = 0)), res;
};
var __commonJS22 = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames22(cb)[0]])((mod = {
exports: {}
}).exports, mod), mod.exports;
};
var __export2 = (target, all) => {
for (var name in all)
__defProp2(target, name, {
get: all[name],
enumerable: true
});
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames22(from))
if (!__hasOwnProp2.call(to, key) && key !== except)
__defProp2(to, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
});
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp2({}, "__esModule", {
value: true
}), mod);
var init_define_process = __esm({
"<define:process>"() {
}
});
var require_doc_builders = __commonJS22({
"src/document/doc-builders.js"(exports22, module22) {
"use strict";
init_define_process();
function concat(parts) {
if (false) {
for (const part of parts) {
assertDoc(part);
}
}
return {
type: "concat",
parts
};
}
function indent(contents) {
if (false) {
assertDoc(contents);
}
return {
type: "indent",
contents
};
}
function align(widthOrString, contents) {
if (false) {
assertDoc(contents);
}
return {
type: "align",
contents,
n: widthOrString
};
}
function group(contents) {
let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
if (false) {
assertDoc(contents);
}
return {
type: "group",
id: opts.id,
contents,
break: Boolean(opts.shouldBreak),
expandedStates: opts.expandedStates
};
}
function dedentToRoot(contents) {
return align(Number.NEGATIVE_INFINITY, contents);
}
function markAsRoot(contents) {
return align({
type: "root"
}, contents);
}
function dedent(contents) {
return align(-1, contents);
}
function conditionalGroup(states, opts) {
return group(states[0], Object.assign(Object.assign({}, opts), {}, {
expandedStates: states
}));
}
function fill(parts) {
if (false) {
for (const part of parts) {
assertDoc(part);
}
}
return {
type: "fill",
parts
};
}
function ifBreak(breakContents, flatContents) {
let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
if (false) {
if (breakContents) {
assertDoc(breakContents);
}
if (flatContents) {
assertDoc(flatContents);
}
}
return {
type: "if-break",
breakContents,
flatContents,
groupId: opts.groupId
};
}
function indentIfBreak(contents, opts) {
return {
type: "indent-if-break",
contents,
groupId: opts.groupId,
negate: opts.negate
};
}
function lineSuffix(contents) {
if (false) {
assertDoc(contents);
}
return {
type: "line-suffix",
contents
};
}
var lineSuffixBoundary = {
type: "line-suffix-boundary"
};
var breakParent = {
type: "break-parent"
};
var trim = {
type: "trim"
};
var hardlineWithoutBreakParent = {
type: "line",
hard: true
};
var literallineWithoutBreakParent = {
type: "line",
hard: true,
literal: true
};
var line = {
type: "line"
};
var softline = {
type: "line",
soft: true
};
var hardline = concat([hardlineWithoutBreakParent, breakParent]);
var literalline = concat([literallineWithoutBreakParent, breakParent]);
var cursor = {
type: "cursor",
placeholder: Symbol("cursor")
};
function join2(sep2, arr) {
const res = [];
for (let i = 0; i < arr.length; i++) {
if (i !== 0) {
res.push(sep2);
}
res.push(arr[i]);
}
return concat(res);
}
function addAlignmentToDoc(doc, size, tabWidth) {
let aligned = doc;
if (size > 0) {
for (let i = 0; i < Math.floor(size / tabWidth); ++i) {
aligned = indent(aligned);
}
aligned = align(size % tabWidth, aligned);
aligned = align(Number.NEGATIVE_INFINITY, aligned);
}
return aligned;
}
function label(label2, contents) {
return {
type: "label",
label: label2,
contents
};
}
module22.exports = {
concat,
join: join2,
line,
softline,
hardline,
literalline,
group,
conditionalGroup,
fill,
lineSuffix,
lineSuffixBoundary,
cursor,
breakParent,
ifBreak,
trim,
indent,
indentIfBreak,
align,
addAlignmentToDoc,
markAsRoot,
dedentToRoot,
dedent,
hardlineWithoutBreakParent,
literallineWithoutBreakParent,
label
};
}
});
var require_end_of_line = __commonJS22({
"src/common/end-of-line.js"(exports22, module22) {
"use strict";
init_define_process();
function guessEndOfLine(text) {
const index = text.indexOf("\r");
if (index >= 0) {
return text.charAt(index + 1) === "\n" ? "crlf" : "cr";
}
return "lf";
}
function convertEndOfLineToChars(value) {
switch (value) {
case "cr":
return "\r";
case "crlf":
return "\r\n";
default:
return "\n";
}
}
function countEndOfLineChars(text, eol) {
let regex;
switch (eol) {
case "\n":
regex = /\n/g;
break;
case "\r":
regex = /\r/g;
break;
case "\r\n":
regex = /\r\n/g;
break;
default: