@vue-jsx-vapor/macros 2.3.0 → 2.3.2

package/dist/core-B1Tt-ieP.cjs

@@ -0,0 +1,438 @@
+"use strict";
+const require_chunk = require('./chunk-BCwAaXi7.cjs');
+const __vue_macros_common = require_chunk.__toESM(require("@vue-macros/common"));
+const __vue_compiler_sfc = require_chunk.__toESM(require("@vue/compiler-sfc"));
+const hash_sum = require_chunk.__toESM(require("hash-sum"));
+
+//#region src/core/helper/use-model.ts?raw
+var use_model_default = "import { customRef, watchSyncEffect } from \"vue\";\nexport function useModel(props, name, options = {}) {\n  const res = customRef((track, trigger) => {\n    let localValue = options && options.default;\n    let prevEmittedValue;\n    watchSyncEffect(() => {\n      const propValue = props[name];\n      if (!Object.is(prevEmittedValue, propValue)) {\n        localValue = propValue;\n        trigger();\n      }\n    });\n    return {\n      get() {\n        track();\n        return options.get ? options.get(localValue) : localValue;\n      },\n      set(value) {\n        if (Object.is(value, localValue)) return;\n        localValue = value;\n        trigger();\n        const emittedValue = prevEmittedValue = options.set ? options.set(value) : value;\n        for (const emit of [props[`onUpdate:${name}`]].flat()) {\n          if (typeof emit === \"function\") emit(emittedValue);\n        }\n      }\n    };\n  });\n  res[Symbol.iterator] = () => {\n    let i = 0;\n    return {\n      next() {\n        if (i < 2) {\n          return {\n            value: i++ ? props[`${name}Modifiers`] || {} : res,\n            done: false\n          };\n        } else {\n          return { done: true };\n        }\n      }\n    };\n  };\n  return res;\n}\n";
+
+//#endregion
+//#region src/core/helper/with-defaults.ts?raw
+var with_defaults_default = "function resolveDefaultProps(paths) {\n  const result = {};\n  for (const path of Object.keys(paths)) {\n    const segments = path.split(/[.?[\\]]/).filter(Boolean);\n    let current = result;\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      if (i === segments.length - 1) {\n        current[segment] = paths[path];\n      } else {\n        if (!current[segment]) {\n          current[segment] = Number.isNaN(Number(segments[i + 1])) ? {} : [];\n        }\n        current = current[segment];\n      }\n    }\n  }\n  return result;\n}\nexport function createPropsDefaultProxy(props, defaults) {\n  const defaultProps = resolveDefaultProps(defaults);\n  const result = {};\n  for (const key of [\n    .../* @__PURE__ */ new Set([...Object.keys(props), ...Object.keys(defaultProps)])\n  ]) {\n    Object.defineProperty(result, key, {\n      enumerable: true,\n      get: () => props[key] === void 0 ? defaultProps[key] : props[key]\n    });\n  }\n  return result;\n}\n";
+
+//#endregion
+//#region src/core/helper/index.ts
+const helperPrefix = "vue-jsx-vapor/macros";
+const useModelHelperId = `${helperPrefix}/use-model`;
+const withDefaultsHelperId = `${helperPrefix}/with-defaults`;
+
+//#endregion
+//#region src/core/restructure.ts
+function restructure(s, node, options = {}) {
+	let index = 0;
+	const propList = [];
+	for (const param of node.params) {
+		const path = `${__vue_macros_common.HELPER_PREFIX}props${index++ || ""}`;
+		const props = getProps(param, path, s, [], options);
+		if (props) {
+			const hasDefaultValue = props.some((i) => i.defaultValue);
+			s.overwrite(param.start, param.end, path);
+			propList.push(...hasDefaultValue ? props.map((i) => ({
+				...i,
+				path: i.path.replace(__vue_macros_common.HELPER_PREFIX, `${__vue_macros_common.HELPER_PREFIX}default_`)
+			})) : props);
+		}
+	}
+	if (propList.length) {
+		const defaultValues = {};
+		const rests = [];
+		for (const prop of propList) {
+			if (prop.defaultValue) {
+				const basePath = prop.path.split(/\.|\[/)[0];
+				(defaultValues[basePath] ??= []).push(prop);
+			}
+			if (prop.isRest) rests.push(prop);
+		}
+		for (const [path, values] of Object.entries(defaultValues)) {
+			const createPropsDefaultProxy = (0, __vue_macros_common.importHelperFn)(s, 0, "createPropsDefaultProxy", void 0, options.withDefaultsFrom ?? withDefaultsHelperId);
+			const resolvedPath = path.replace(`${__vue_macros_common.HELPER_PREFIX}default_`, __vue_macros_common.HELPER_PREFIX);
+			const resolvedValues = values.map((i) => `'${i.path.replace(path, "")}${i.value}': ${i.defaultValue}`).join(", ");
+			prependFunctionalNode(node, s, `\nconst ${path} = ${createPropsDefaultProxy}(${resolvedPath}, {${resolvedValues}})`);
+		}
+		for (const [index$1, rest] of rests.entries()) prependFunctionalNode(node, s, options.generateRestProps?.(rest.name, index$1, rests) ?? `\nconst ${rest.name} = ${(0, __vue_macros_common.importHelperFn)(s, 0, "createPropsRestProxy")}(${rest.path}, [${rest.value}])`);
+		(0, __vue_compiler_sfc.walkIdentifiers)(node.body, (id, parent) => {
+			const prop = propList.find((i) => i.name === id.name);
+			if (prop && !prop.isRest) s.overwrite(id.start, id.end, `${parent?.type === "ObjectProperty" && parent.shorthand ? `${id.name}: ` : ""}${prop.path}${prop.value}`);
+		}, false);
+	}
+	return propList;
+}
+function getProps(node, path = "", s, props = [], options) {
+	const properties = node.type === "ObjectPattern" ? node.properties : node.type === "ArrayPattern" ? node.elements : [];
+	if (!properties.length) return;
+	const propNames = [];
+	properties.forEach((prop, index) => {
+		if (prop?.type === "Identifier") {
+			props.push({
+				name: prop.name,
+				path,
+				value: `[${index}]`
+			});
+			propNames.push(`'${prop.name}'`);
+		} else if (prop?.type === "AssignmentPattern" && prop.left.type === "Identifier") {
+			props.push({
+				path,
+				name: prop.left.name,
+				value: `[${index}]`,
+				defaultValue: s.slice(prop.right.start, prop.right.end)
+			});
+			propNames.push(`'${prop.left.name}'`);
+		} else if (prop?.type === "ObjectProperty" && prop.key.type === "Identifier") {
+			if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") props.push({
+				path,
+				name: prop.value.left.name,
+				value: `.${prop.key.name}`,
+				defaultValue: s.slice(prop.value.right.start, prop.value.right.end),
+				isRequired: prop.value.right.type === "TSNonNullExpression"
+			});
+			else if (!getProps(prop.value, `${path}.${prop.key.name}`, s, props, options)) props.push({
+				path,
+				name: prop.value.type === "Identifier" ? prop.value.name : prop.key.name,
+				value: `.${prop.key.name}`
+			});
+			propNames.push(`'${prop.key.name}'`);
+		} else if (prop?.type === "RestElement" && prop.argument.type === "Identifier" && !prop.argument.name.startsWith(`${__vue_macros_common.HELPER_PREFIX}props`)) props.push({
+			path,
+			name: prop.argument.name,
+			value: propNames.join(", "),
+			isRest: true
+		});
+		else if (prop) getProps(prop, `${path}[${index}]`, s, props, options);
+	});
+	return props.length ? props : void 0;
+}
+function prependFunctionalNode(node, s, result) {
+	const isBlockStatement = node.body.type === "BlockStatement";
+	const start = node.body.extra?.parenthesized ? node.body.extra.parenStart : node.body.start;
+	s.appendRight(start + (isBlockStatement ? 1 : 0), `${result};${!isBlockStatement ? "return " : ""}`);
+	if (!isBlockStatement) {
+		s.appendLeft(start, "{");
+		s.appendRight(node.end, "}");
+	}
+}
+
+//#endregion
+//#region src/core/define-component/await.ts
+const isFunctionType = (node) => {
+	return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+function transformAwait(root, s) {
+	if (root.body.type !== "BlockStatement") return;
+	let hasAwait = false;
+	for (const node of root.body.body) if (node.type === "VariableDeclaration" && !node.declare || node.type.endsWith("Statement")) {
+		const scope = [root.body.body];
+		(0, __vue_macros_common.walkAST)(node, {
+			enter(child, parent) {
+				if (isFunctionType(child)) this.skip();
+				if (child.type === "BlockStatement") scope.push(child.body);
+				if (child.type === "AwaitExpression") {
+					hasAwait = true;
+					const currentScope = scope.at(-1);
+					const needsSemi = !!currentScope?.some((n, i) => {
+						return (scope.length === 1 || i > 0) && n.type === "ExpressionStatement" && n.start === child.start;
+					});
+					processAwait(s, child, needsSemi, parent.type === "ExpressionStatement");
+				}
+			},
+			leave(node$1) {
+				if (node$1.type === "BlockStatement") scope.pop();
+			}
+		});
+	}
+	if (hasAwait) s.prependLeft(root.body.start + 1, `\nlet __temp, __restore\n`);
+}
+function processAwait(s, node, needSemi, isStatement) {
+	const argumentStart = node.argument.extra && node.argument.extra.parenthesized ? node.argument.extra.parenStart : node.argument.start;
+	const argumentStr = s.slice(argumentStart, node.argument.end);
+	const containsNestedAwait = /\bawait\b/.test(argumentStr);
+	s.overwrite(node.start, argumentStart, `${needSemi ? `;` : ``}(\n  ([__temp,__restore] = ${(0, __vue_macros_common.importHelperFn)(s, 0, `withAsyncContext`)}(${containsNestedAwait ? `async ` : ``}() => `);
+	s.appendLeft(node.end, `)),\n  ${isStatement ? `` : `__temp = `}await __temp,\n  __restore()${isStatement ? `` : `,\n  __temp`}\n)`);
+}
+
+//#endregion
+//#region src/core/define-component/return.ts
+function transformReturn(root, s) {
+	const node = root.body.type === "BlockStatement" ? root.body.body.find((node$1) => node$1.type === "ReturnStatement")?.argument : root.body;
+	if (!node || isFunctionalNode(node)) return;
+	s.appendRight(node.extra?.parenthesized ? node.extra.parenStart : node.start, "() => ");
+}
+
+//#endregion
+//#region src/core/define-component/index.ts
+function transformDefineComponent(root, propsName, map, s, autoReturnFunction = false) {
+	if (!map.defineComponent) return;
+	const defineComponentName = s.sliceNode(map.defineComponent.callee);
+	if (defineComponentName && !["defineComponent", "defineVaporComponent"].includes(defineComponentName)) (0, __vue_macros_common.importHelperFn)(s, 0, "defineComponent", defineComponentName);
+	let hasRestProp = false;
+	const props = {};
+	if (root.params[0]) if (root.params[0].type === "Identifier") getWalkedIds(root, propsName).forEach((id) => props[id] = null);
+	else {
+		const restructuredProps = restructure(s, root, { generateRestProps: (restPropsName, index, list) => {
+			if (index === list.length - 1) {
+				hasRestProp = true;
+				const useAttrs = (0, __vue_macros_common.importHelperFn)(s, 0, "useAttrs");
+				return `const ${restPropsName} = ${useAttrs}()`;
+			}
+		} });
+		for (const prop of restructuredProps) if (prop.path.endsWith("props") && !prop.isRest) props[prop.name] = prop.isRequired ? "{ required: true }" : null;
+	}
+	for (const { expression, isRequired } of map.defineModel || []) {
+		const modelOptions = expression.arguments[0]?.type === "ObjectExpression" ? expression.arguments[0] : expression.arguments[1]?.type === "ObjectExpression" ? expression.arguments[1] : void 0;
+		const options = {};
+		if (isRequired) options.required = true;
+		for (const prop of modelOptions?.properties || []) if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && [
+			"validator",
+			"type",
+			"required"
+		].includes(prop.key.name)) options[prop.key.name] = s.sliceNode(prop.value);
+		const propName = expression.arguments[0]?.type === "StringLiteral" ? expression.arguments[0].value : "modelValue";
+		props[propName] = Object.keys(options).length ? `{ ${Object.entries(options).map(([key, value]) => `${key}: ${value}`).join(", ")} }` : null;
+		props[`onUpdate:${propName}`] = null;
+		props[`${propName === "modelValue" ? "model" : propName}Modifiers`] = null;
+	}
+	const propsString = Object.entries(props).map(([key, value]) => `'${key}': ${value}`).join(", ");
+	if (propsString) {
+		const argument = map.defineComponent.arguments[1];
+		if (!argument) s.appendRight(root.end, `, {${hasRestProp ? "inheritAttrs: false," : ""} props: { ${propsString} } }`);
+		else if (argument.type === "ObjectExpression") {
+			prependObjectExpression(argument, "props", `{ ${propsString} }`, s);
+			if (hasRestProp) prependObjectExpression(argument, "inheritAttrs", "false", s);
+		}
+	}
+	transformAwait(root, s);
+	if (autoReturnFunction) transformReturn(root, s);
+}
+function prependObjectExpression(argument, name, value, s) {
+	if (!argument.properties?.find((prop) => prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === name)) s.appendRight(argument.start + 1, `${name}: ${value},`);
+}
+function getWalkedIds(root, propsName) {
+	const walkedIds = new Set();
+	(0, __vue_compiler_sfc.walkIdentifiers)(root.body, (id, parent) => {
+		if (id.name === propsName && (parent?.type === "MemberExpression" || parent?.type === "OptionalMemberExpression")) {
+			const prop = parent.property.type === "Identifier" ? parent.property.name : parent.property.type === "StringLiteral" ? parent.property.value : "";
+			if (prop) walkedIds.add(prop);
+		}
+	}, false);
+	return walkedIds;
+}
+
+//#endregion
+//#region src/core/define-expose.ts
+function transformDefineExpose(node, s, version) {
+	s.overwriteNode(node.callee, ";");
+	s.appendRight(node.arguments[0]?.start || node.end - 1, version >= 3.6 ? `${(0, __vue_macros_common.importHelperFn)(s, 0, "currentInstance")}.exposed = ` : `${(0, __vue_macros_common.importHelperFn)(s, 0, "getCurrentInstance")}().exposed = `);
+}
+
+//#endregion
+//#region src/core/define-model.ts
+function transformDefineModel(node, propsName, s) {
+	s.overwriteNode(node.callee, (0, __vue_macros_common.importHelperFn)(s, 0, "useModel", void 0, useModelHelperId));
+	s.appendRight(node.arguments[0]?.start || node.end - 1, `${propsName}, ${node.arguments[0]?.type !== "StringLiteral" ? `'modelValue',` : ""}`);
+}
+
+//#endregion
+//#region src/core/define-slots.ts
+function transformDefineSlots(node, s) {
+	s.overwrite(node.start, node.arguments[0]?.start && node.arguments[0].start - 1 || node.typeArguments?.end || node.callee.end, `Object.assign`);
+	const slots = `${(0, __vue_macros_common.importHelperFn)(s, 0, "useSlots")}()`;
+	s.appendLeft(node.end - 1, `${node.arguments[0] ? "," : "{}, "}${slots}`);
+}
+
+//#endregion
+//#region src/core/define-style.ts
+function transformDefineStyle(defineStyle, index, root, s, importMap) {
+	const { expression, lang, isDeclaration } = defineStyle;
+	if (expression.arguments[0]?.type !== "TemplateLiteral") return;
+	let css = s.sliceNode(expression.arguments[0]).slice(1, -1);
+	const scopeId = (0, hash_sum.default)(css);
+	const vars = new Map();
+	expression.arguments[0].expressions.forEach((exp) => {
+		const cssVar = s.sliceNode(exp);
+		const cssVarId = toCssVarId(cssVar, `--${scopeId}-`);
+		s.overwrite(exp.start - 2, exp.end + 1, `var(${cssVarId})`);
+		vars.set(cssVarId, cssVar);
+	});
+	let returnExpression = root && getReturnStatement(root);
+	if (isFunctionalNode(returnExpression)) returnExpression = getReturnStatement(returnExpression);
+	if (vars.size && returnExpression) {
+		const children = returnExpression.type === "JSXElement" ? [returnExpression] : returnExpression.type === "JSXFragment" ? returnExpression.children : [];
+		const varString = Array.from(vars.entries()).map(([key, value]) => `'${key}': ${value}`).join(", ");
+		for (const child of children) if (child.type === "JSXElement") s.appendRight(child.openingElement.name.end, ` {...{style:{${varString}}}}`);
+	}
+	let scoped = !!root;
+	if (expression.arguments[1]?.type === "ObjectExpression") {
+		for (const prop of expression.arguments[1].properties) if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "scoped" && prop.value.type === "BooleanLiteral") scoped = prop.value.value;
+	}
+	if (scoped && returnExpression) (0, __vue_macros_common.walkAST)(returnExpression, { enter(node) {
+		if (node.type === "JSXElement" && s.sliceNode(node.openingElement.name) !== "template") s.appendRight(node.openingElement.name.end, ` data-v-${scopeId}=""`);
+	} });
+	css = s.sliceNode(expression.arguments[0]).slice(1, -1).replaceAll(/\/\/(.*)(?=\n)/g, "/*$1*/");
+	const module$1 = isDeclaration ? "module." : "";
+	const importId = `${helperPrefix}/define-style/${index}?scopeId=${scopeId}&scoped=${scoped}&lang.${module$1}${lang}`;
+	importMap.set(importId, css);
+	s.appendLeft(0, isDeclaration ? `import style${index} from "${importId}";` : `import "${importId}";`);
+	s.overwriteNode(expression, isDeclaration ? `style${index}` : "");
+}
+function getReturnStatement(root) {
+	if (root.body.type === "BlockStatement") {
+		const returnStatement = root.body.body.find((node) => node.type === "ReturnStatement");
+		if (returnStatement) return returnStatement.argument;
+	} else return root.body;
+}
+function toCssVarId(name, prefix = "") {
+	return prefix + name.replaceAll(/\W/g, (searchValue, replaceValue) => {
+		return searchValue === "." ? "-" : name.charCodeAt(replaceValue).toString();
+	});
+}
+
+//#endregion
+//#region src/core/index.ts
+function transformJsxMacros(code, id, importMap, options) {
+	const s = new __vue_macros_common.MagicStringAST(code);
+	const ast = (0, __vue_macros_common.babelParse)(s.original, (0, __vue_macros_common.getLang)(id));
+	const rootMap = getRootMap(ast, s, options);
+	let defineStyleIndex = 0;
+	for (const [root, map] of rootMap) {
+		map.defineStyle?.forEach((defineStyle) => {
+			transformDefineStyle(defineStyle, defineStyleIndex++, root, s, importMap);
+		});
+		if (root === void 0) continue;
+		let propsName = `${__vue_macros_common.HELPER_PREFIX}props`;
+		if (root.params[0]) {
+			if (root.params[0].type === "Identifier") propsName = root.params[0].name;
+			else if (root.params[0].type === "ObjectPattern") {
+				const lastProp = root.params[0].properties.at(-1);
+				if (!map.defineComponent && lastProp?.type === "RestElement" && lastProp.argument.type === "Identifier") propsName = lastProp.argument.name;
+				else s.appendRight(root.params[0].extra?.trailingComma ? root.params[0].extra?.trailingComma + 1 : lastProp?.end || root.params[0].end - 1, `${!root.params[0].extra?.trailingComma && root.params[0].properties.length ? "," : ""} ...${__vue_macros_common.HELPER_PREFIX}props`);
+			}
+		} else s.appendRight(getParamsStart(root, s.original), propsName);
+		if (map.defineComponent) transformDefineComponent(root, propsName, map, s, options.defineComponent?.autoReturnFunction);
+		if (map.defineModel?.length) map.defineModel.forEach(({ expression }) => {
+			transformDefineModel(expression, propsName, s);
+		});
+		if (map.defineSlots) transformDefineSlots(map.defineSlots, s);
+		if (map.defineExpose) transformDefineExpose(map.defineExpose, s, options.version);
+	}
+	return (0, __vue_macros_common.generateTransform)(s, id);
+}
+function getRootMap(ast, s, options) {
+	const parents = [];
+	const rootMap = new Map();
+	(0, __vue_macros_common.walkAST)(ast, {
+		enter(node, parent) {
+			parents.unshift(parent);
+			const root = isFunctionalNode(parents[1]) ? parents[1] : void 0;
+			if (root && parents[2]?.type === "CallExpression" && options.defineComponent.alias.includes(s.sliceNode(parents[2].callee))) {
+				if (!rootMap.has(root)) rootMap.set(root, {});
+				if (!rootMap.get(root).defineComponent) rootMap.get(root).defineComponent = parents[2];
+			}
+			const expression = node.type === "VariableDeclaration" ? node.declarations[0].init?.type === "CallExpression" && s.sliceNode(node.declarations[0].init.callee) === "$" ? node.declarations[0].init.arguments[0] : node.declarations[0].init : node.type === "ExpressionStatement" ? node.expression : void 0;
+			if (!expression) return;
+			const macroExpression = getMacroExpression(expression, options);
+			if (!macroExpression) return;
+			if (!rootMap.has(root)) rootMap.set(root, {});
+			const macroName = s.sliceNode(macroExpression.callee.type === "MemberExpression" ? macroExpression.callee.object : macroExpression.callee);
+			if (macroName) {
+				if (options.defineModel.alias.includes(macroName)) (rootMap.get(root).defineModel ??= []).push({
+					expression: macroExpression,
+					isRequired: expression.type === "TSNonNullExpression"
+				});
+				else if (options.defineStyle.alias.includes(macroName)) {
+					const lang = macroExpression.callee.type === "MemberExpression" && macroExpression.callee.property.type === "Identifier" ? macroExpression.callee.property.name : "css";
+					(rootMap.get(root).defineStyle ??= []).push({
+						expression: macroExpression,
+						isDeclaration: node.type === "VariableDeclaration",
+						lang
+					});
+				} else if (options.defineSlots.alias.includes(macroName)) rootMap.get(root).defineSlots = macroExpression;
+				else if (options.defineExpose.alias.includes(macroName)) rootMap.get(root).defineExpose = macroExpression;
+			}
+		},
+		leave() {
+			parents.shift();
+		}
+	});
+	return rootMap;
+}
+function isFunctionalNode(node) {
+	return !!(node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression"));
+}
+function getMacroExpression(node, options) {
+	if (node.type === "TSNonNullExpression") node = node.expression;
+	if (node.type === "CallExpression") {
+		if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "defineStyle") return node;
+		else if (node.callee.type === "Identifier" && [
+			...options.defineComponent.alias,
+			...options.defineSlots.alias,
+			...options.defineModel.alias,
+			...options.defineExpose.alias,
+			...options.defineStyle.alias
+		].includes(node.callee.name)) return node;
+	}
+}
+function getParamsStart(node, code) {
+	return node.params[0] ? node.params[0].start : node.start + (code.slice(node.start, node.body.start).match(/\(\s*\)/)?.index || 0) + 1;
+}
+
+//#endregion
+Object.defineProperty(exports, 'getMacroExpression', {
+  enumerable: true,
+  get: function () {
+    return getMacroExpression;
+  }
+});
+Object.defineProperty(exports, 'getParamsStart', {
+  enumerable: true,
+  get: function () {
+    return getParamsStart;
+  }
+});
+Object.defineProperty(exports, 'helperPrefix', {
+  enumerable: true,
+  get: function () {
+    return helperPrefix;
+  }
+});
+Object.defineProperty(exports, 'isFunctionalNode', {
+  enumerable: true,
+  get: function () {
+    return isFunctionalNode;
+  }
+});
+Object.defineProperty(exports, 'restructure', {
+  enumerable: true,
+  get: function () {
+    return restructure;
+  }
+});
+Object.defineProperty(exports, 'transformJsxMacros', {
+  enumerable: true,
+  get: function () {
+    return transformJsxMacros;
+  }
+});
+Object.defineProperty(exports, 'useModelHelperId', {
+  enumerable: true,
+  get: function () {
+    return useModelHelperId;
+  }
+});
+Object.defineProperty(exports, 'use_model_default', {
+  enumerable: true,
+  get: function () {
+    return use_model_default;
+  }
+});
+Object.defineProperty(exports, 'withDefaultsHelperId', {
+  enumerable: true,
+  get: function () {
+    return withDefaultsHelperId;
+  }
+});
+Object.defineProperty(exports, 'with_defaults_default', {
+  enumerable: true,
+  get: function () {
+    return with_defaults_default;
+  }
+});