studiocms 0.1.0-beta.10

package/dist/routes/dashboard/studiocms_api/dashboard/content/page.d.ts

@@ -0,0 +1,6 @@
+import type { APIRoute } from 'astro';
+export declare const POST: APIRoute;
+export declare const PATCH: APIRoute;
+export declare const DELETE: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/dashboard/studiocms_api/dashboard/content/page.js

@@ -0,0 +1,258 @@
+import { getUserData, verifyUserPermissionLevel } from "studiocms:auth/lib/user";
+import { developerConfig } from "studiocms:config";
+import plugins from "studiocms:plugins";
+import studioCMS_SDK from "studiocms:sdk";
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+import { simpleResponse } from "../../../../../utils/simpleResponse.js";
+const pageTypeOptions = plugins.flatMap(({ pageTypes }) => {
+  const pageTypeOutput = [];
+  if (!pageTypes) {
+    return pageTypeOutput;
+  }
+  for (const pageType of pageTypes) {
+    pageTypeOutput.push(pageType);
+  }
+  return pageTypeOutput;
+});
+function getPageTypeEndpoints(pkg, type) {
+  const currentPageType = pageTypeOptions.find((pageType) => pageType.identifier === pkg);
+  if (!currentPageType) {
+    return void 0;
+  }
+  return currentPageType.apiEndpoints?.[type];
+}
+const { testingAndDemoMode } = developerConfig;
+function getParentFolderValue(value) {
+  if (value === "null") return null;
+  return value;
+}
+const POST = async (context) => {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const userData = await getUserData(context);
+  if (!userData.isLoggedIn) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const isAuthorized = await verifyUserPermissionLevel(userData, "editor");
+  if (!isAuthorized) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const formData = await context.request.formData();
+  const data = {
+    title: formData.get("page-title")?.toString(),
+    slug: formData.get("page-slug")?.toString(),
+    description: formData.get("page-description")?.toString(),
+    package: formData.get("page-type")?.toString(),
+    showOnNav: formData.get("show-in-nav")?.toString() === "true",
+    heroImage: formData.get("page-hero-image")?.toString(),
+    parentFolder: getParentFolderValue(formData.get("parent-folder")?.toString()),
+    showAuthor: formData.get("show-author")?.toString() === "true",
+    showContributors: formData.get("show-contributors")?.toString() === "true",
+    categories: [],
+    tags: [],
+    draft: true
+  };
+  const content = {
+    id: crypto.randomUUID(),
+    content: formData.get("page-content")?.toString() ?? ""
+  };
+  if (!data) {
+    return simpleResponse(400, "Invalid form data, data is required");
+  }
+  if (!content) {
+    return simpleResponse(400, "Invalid form data, content is required");
+  }
+  const dataId = crypto.randomUUID();
+  const contentId = crypto.randomUUID();
+  if (!data.title) {
+    return simpleResponse(400, "Invalid form data, title is required");
+  }
+  const apiRoute = getPageTypeEndpoints(data.package, "onCreate");
+  try {
+    await studioCMS_SDK.POST.databaseEntry.pages(
+      {
+        id: dataId,
+        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+        title: data.title,
+        slug: data.slug || data.title.toLowerCase().replace(/\s/g, "-"),
+        description: data.description || "",
+        authorId: userData.user?.id || null,
+        ...data
+      },
+      { id: contentId, ...content }
+    );
+    if (apiRoute) {
+      await apiRoute(context);
+    }
+    studioCMS_SDK_Cache.CLEAR.pages();
+    return simpleResponse(200, "Page created successfully");
+  } catch (error) {
+    return simpleResponse(500, "Failed to create page");
+  }
+};
+const PATCH = async (context) => {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const userData = await getUserData(context);
+  if (!userData.isLoggedIn) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const isAuthorized = await verifyUserPermissionLevel(userData, "editor");
+  if (!isAuthorized) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const formData = await context.request.formData();
+  const data = {
+    title: formData.get("page-title")?.toString(),
+    slug: formData.get("page-slug")?.toString(),
+    description: formData.get("page-description")?.toString(),
+    package: formData.get("page-type")?.toString(),
+    showOnNav: formData.get("show-in-nav") === "true",
+    heroImage: formData.get("page-hero-image")?.toString(),
+    parentFolder: getParentFolderValue(formData.get("parent-folder")?.toString()),
+    showAuthor: formData.get("show-author") === "true",
+    showContributors: formData.get("show-contributors")?.toString() === "true",
+    categories: [],
+    tags: [],
+    id: formData.get("page-id")?.toString(),
+    draft: formData.get("draft")?.toString() === "true"
+  };
+  const content = {
+    id: formData.get("page-content-id")?.toString(),
+    content: formData.get("page-content")?.toString()
+  };
+  if (!data) {
+    return simpleResponse(400, "Invalid form data, data is required");
+  }
+  if (!content) {
+    return simpleResponse(400, "Invalid form data, content is required");
+  }
+  if (!data.id) {
+    return simpleResponse(400, "Invalid form data, id is required");
+  }
+  if (!content.id) {
+    return simpleResponse(400, "Invalid form data, id is required");
+  }
+  const currentPageData = await studioCMS_SDK_Cache.GET.page.byId(data.id);
+  if (!currentPageData.data) {
+    return simpleResponse(404, "Page not found");
+  }
+  const { authorId, contributorIds } = currentPageData.data;
+  let AuthorId = authorId;
+  if (!authorId) {
+    AuthorId = userData.user?.id || null;
+  }
+  const ContributorIds = contributorIds || [];
+  if (!ContributorIds.includes(userData.user.id)) {
+    ContributorIds.push(userData.user.id);
+  }
+  data.authorId = AuthorId;
+  data.contributorIds = JSON.stringify(ContributorIds);
+  data.updatedAt = /* @__PURE__ */ new Date();
+  const startMetaData = (await studioCMS_SDK.GET.databaseTable.pageData()).find(
+    (metaData) => metaData.id === data.id
+  );
+  const {
+    data: { defaultContent }
+  } = await studioCMS_SDK_Cache.GET.page.byId(data.id);
+  const apiRoute = getPageTypeEndpoints(data.package, "onEdit");
+  try {
+    await studioCMS_SDK_Cache.UPDATE.page.byId(data.id, {
+      pageData: data,
+      pageContent: content
+    });
+    const updatedMetaData = (await studioCMS_SDK.GET.databaseTable.pageData()).find(
+      (metaData) => metaData.id === data.id
+    );
+    const { enableDiffs, diffPerPage } = (await studioCMS_SDK_Cache.GET.siteConfig()).data;
+    if (enableDiffs) {
+      await studioCMS_SDK.diffTracking.insert(
+        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+        userData.user.id,
+        data.id,
+        {
+          content: {
+            start: defaultContent?.content || "",
+            end: content.content || ""
+          },
+          // biome-ignore lint/style/noNonNullAssertion: <explanation>
+          metaData: { start: startMetaData, end: updatedMetaData }
+        },
+        diffPerPage
+      );
+    }
+    if (apiRoute) {
+      await apiRoute(context);
+    }
+    return simpleResponse(200, "Page updated successfully");
+  } catch (error) {
+    return simpleResponse(500, "Failed to update page");
+  }
+};
+const DELETE = async (context) => {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const userData = await getUserData(context);
+  if (!userData.isLoggedIn) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const isAuthorized = await verifyUserPermissionLevel(userData, "admin");
+  if (!isAuthorized) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const jsonData = await context.request.json();
+  const { id, slug } = jsonData;
+  if (!id) {
+    return simpleResponse(400, "Invalid request");
+  }
+  if (!slug) {
+    return simpleResponse(400, "Invalid request");
+  }
+  const isHomePage = await studioCMS_SDK_Cache.GET.page.bySlug("index");
+  if (isHomePage.data && isHomePage.data.id === id) {
+    return simpleResponse(400, "Cannot delete home page");
+  }
+  const pageToDelete = await studioCMS_SDK_Cache.GET.page.byId(id);
+  const apiRoute = getPageTypeEndpoints(pageToDelete.data.package, "onCreate");
+  try {
+    await studioCMS_SDK.DELETE.page(id);
+    studioCMS_SDK_Cache.CLEAR.page.byId(id);
+    if (apiRoute) {
+      await apiRoute(context);
+    }
+    return simpleResponse(200, "Page deleted successfully");
+  } catch (error) {
+    return simpleResponse(500, "Failed to delete page");
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, POST, DELETE, PATCH",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  DELETE,
+  OPTIONS,
+  PATCH,
+  POST
+};

package/dist/routes/dashboard/studiocms_api/dashboard/create-reset-link.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/dashboard/studiocms_api/dashboard/create-reset-link.js

@@ -0,0 +1,59 @@
+import { getUserData, verifyUserPermissionLevel } from "studiocms:auth/lib/user";
+import { developerConfig } from "studiocms:config";
+import studioCMS_SDK from "studiocms:sdk";
+import { simpleResponse } from "../../../../utils/simpleResponse.js";
+const { testingAndDemoMode } = developerConfig;
+const POST = async (ctx) => {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const userData = await getUserData(ctx);
+  if (!userData.isLoggedIn) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const isAuthorized = await verifyUserPermissionLevel(userData, "admin");
+  if (!isAuthorized) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const jsonData = await ctx.request.json();
+  const { userId } = jsonData;
+  if (!userId) {
+    return simpleResponse(400, "Invalid form data, userId is required");
+  }
+  const token = await studioCMS_SDK.resetTokenBucket.new(userId);
+  if (!token) {
+    return simpleResponse(500, "Failed to create reset link");
+  }
+  return new Response(JSON.stringify(token), {
+    headers: {
+      "content-type": "application/json"
+    },
+    status: 200
+  });
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, POST",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  OPTIONS,
+  POST
+};

package/dist/routes/dashboard/studiocms_api/dashboard/create-user-invite.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/dashboard/studiocms_api/dashboard/create-user-invite.js

@@ -0,0 +1,105 @@
+import {
+  getUserData,
+  verifyUserPermissionLevel,
+  verifyUsernameInput
+} from "studiocms:auth/lib/user";
+import { developerConfig } from "studiocms:config";
+import { StudioCMSRoutes, removeLeadingTrailingSlashes } from "studiocms:lib";
+import studioCMS_SDK from "studiocms:sdk";
+import { z } from "astro/zod";
+import { simpleResponse } from "../../../../utils/simpleResponse.js";
+const { testingAndDemoMode } = developerConfig;
+const POST = async (ctx) => {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const userData = await getUserData(ctx);
+  if (!userData.isLoggedIn) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const isAuthorized = await verifyUserPermissionLevel(userData, "admin");
+  if (!isAuthorized) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const jsonData = await ctx.request.json();
+  const { username, email, displayname, rank, originalUrl } = jsonData;
+  if (!username) {
+    return simpleResponse(400, "Missing field: Username is required");
+  }
+  if (!email) {
+    return simpleResponse(400, "Missing field: Email is required");
+  }
+  if (!displayname) {
+    return simpleResponse(400, "Missing field: Display name is required");
+  }
+  if (!rank) {
+    return simpleResponse(400, "Missing field: Rank is required");
+  }
+  if (verifyUsernameInput(username) !== true) {
+    return simpleResponse(
+      400,
+      "Invalid username: Username must be between 3 and 20 characters, only contain lowercase letters, numbers, -, and _ as well as not be a commonly used username (admin, root, etc.)"
+    );
+  }
+  const checkEmail = z.coerce.string().email({ message: "Email address is invalid" }).safeParse(email);
+  if (!checkEmail.success) {
+    return simpleResponse(400, `Invalid email: ${checkEmail.error.message}`);
+  }
+  const { usernameSearch, emailSearch } = await studioCMS_SDK.AUTH.user.searchUsersForUsernameOrEmail(username, checkEmail.data);
+  if (usernameSearch.length > 0) {
+    return simpleResponse(400, "Invalid username: Username is already in use");
+  }
+  if (emailSearch.length > 0) {
+    return simpleResponse(400, "Invalid email: Email is already in use");
+  }
+  function generateResetLink(token2) {
+    return `${originalUrl}${StudioCMSRoutes.mainLinks.dashboardIndex}/reset-password?userid=${token2.userId}&token=${token2.token}&id=${token2.id}`;
+  }
+  const newUser = await studioCMS_SDK.AUTH.user.create(
+    {
+      username,
+      email: checkEmail.data,
+      name: displayname,
+      createdAt: /* @__PURE__ */ new Date(),
+      id: crypto.randomUUID()
+    },
+    rank
+  );
+  const token = await studioCMS_SDK.resetTokenBucket.new(newUser.id);
+  if (!token) {
+    return simpleResponse(500, "Failed to create reset token");
+  }
+  const resetLink = generateResetLink(token);
+  return new Response(JSON.stringify({ link: resetLink }), {
+    headers: {
+      "content-type": "application/json"
+    },
+    status: 200
+  });
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, POST",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  OPTIONS,
+  POST
+};

package/dist/routes/dashboard/studiocms_api/dashboard/create-user.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/dashboard/studiocms_api/dashboard/create-user.js

@@ -0,0 +1,100 @@
+import { verifyPasswordStrength } from "studiocms:auth/lib/password";
+import {
+  createLocalUser,
+  getUserData,
+  verifyUserPermissionLevel,
+  verifyUsernameInput
+} from "studiocms:auth/lib/user";
+import { developerConfig } from "studiocms:config";
+import studioCMS_SDK from "studiocms:sdk";
+import { z } from "astro/zod";
+import { simpleResponse } from "../../../../utils/simpleResponse.js";
+const { testingAndDemoMode } = developerConfig;
+const POST = async (ctx) => {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const userData = await getUserData(ctx);
+  if (!userData.isLoggedIn) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const isAuthorized = await verifyUserPermissionLevel(userData, "admin");
+  if (!isAuthorized) {
+    return simpleResponse(403, "Unauthorized");
+  }
+  const jsonData = await ctx.request.json();
+  let { username, password, email, displayname, rank } = jsonData;
+  if (!username) {
+    return simpleResponse(400, "Missing field: Username is required");
+  }
+  if (!password) {
+    password = studioCMS_SDK.generateRandomPassword(12);
+  }
+  if (!email) {
+    return simpleResponse(400, "Missing field: Email is required");
+  }
+  if (!displayname) {
+    return simpleResponse(400, "Missing field: Display name is required");
+  }
+  if (!rank) {
+    return simpleResponse(400, "Missing field: Rank is required");
+  }
+  if (verifyUsernameInput(username) !== true) {
+    return simpleResponse(
+      400,
+      "Invalid username: Username must be between 3 and 20 characters, only contain lowercase letters, numbers, -, and _ as well as not be a commonly used username (admin, root, etc.)"
+    );
+  }
+  if (await verifyPasswordStrength(password) !== true) {
+    return simpleResponse(
+      400,
+      'Invalid password: Password must be between 6 and 255 characters, and not be in the <a href="https://haveibeenpwned.com/Passwords" target="_blank">pwned password database</a>.'
+    );
+  }
+  const checkEmail = z.coerce.string().email({ message: "Email address is invalid" }).safeParse(email);
+  if (!checkEmail.success) {
+    return simpleResponse(400, `Invalid email: ${checkEmail.error.message}`);
+  }
+  const { usernameSearch, emailSearch } = await studioCMS_SDK.AUTH.user.searchUsersForUsernameOrEmail(username, checkEmail.data);
+  if (usernameSearch.length > 0) {
+    return simpleResponse(400, "Invalid username: Username is already in use");
+  }
+  if (emailSearch.length > 0) {
+    return simpleResponse(400, "Invalid email: Email is already in use");
+  }
+  const newUser = await createLocalUser(displayname, username, email, password);
+  const updateRank = await studioCMS_SDK.UPDATE.permissions({
+    user: newUser.id,
+    rank
+  });
+  return simpleResponse(
+    200,
+    JSON.stringify({ username, email, displayname, rank: updateRank.rank, password })
+  );
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, POST",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  OPTIONS,
+  POST
+};

package/dist/routes/dashboard/studiocms_api/dashboard/partials/Editor.astro

@@ -0,0 +1,61 @@
+---
+import pluginsList from 'studiocms:plugins';
+
+const pageTypeComponents = async () => {
+	const pageTypeComponents: {
+		identifier: string;
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		Component: (Props?: { content?: string | null | undefined }) => any;
+	}[] = [];
+
+	for (const { pageTypes } of pluginsList) {
+		if (!pageTypes) {
+			return pageTypeComponents;
+		}
+
+		for (const { identifier, pageContentComponent } of pageTypes) {
+			if (!pageContentComponent) {
+				continue;
+			}
+
+			pageTypeComponents.push({
+				identifier,
+				Component: (await import(/* @vite-ignore */ pageContentComponent)).default,
+			});
+		}
+
+		return pageTypeComponents;
+	}
+
+	return pageTypeComponents;
+};
+
+export const partial = true;
+
+async function setContent() {
+	const jsonData: { content: string | undefined; editor: string } | undefined =
+		await Astro.request.json();
+
+	const editors = await pageTypeComponents();
+
+	let currentEditor = editors.find((ed) => {
+		if (ed.identifier === jsonData?.editor) {
+			return ed;
+		}
+	});
+
+	if (!currentEditor) {
+		// biome-ignore lint/style/noNonNullAssertion: <explanation>
+		currentEditor = editors.find((editor) => editor.identifier === 'studiocms/markdown')!;
+	}
+
+	if (jsonData?.content) {
+		return { content: jsonData.content, ActiveEditor: currentEditor.Component };
+	}
+
+	return { content: 'No content to display', ActiveEditor: currentEditor.Component };
+}
+
+const { content, ActiveEditor } = await setContent();
+---
+<ActiveEditor content={content} />

package/dist/routes/dashboard/studiocms_api/dashboard/partials/LiveRender.astro

@@ -0,0 +1,30 @@
+---
+export const partial = true;
+import { StudioCMSRenderer } from 'studiocms:renderer';
+
+type Content = string;
+
+const queryParam = Astro.url.searchParams.get('content');
+const preQuery = Astro.url.searchParams.get('preload-content');
+
+async function setContent() {
+	const jsonData: { content: string | undefined } | undefined = await Astro.request.json();
+
+	if (jsonData?.content) {
+		return jsonData.content;
+	}
+
+	if (queryParam && queryParam !== 'null') {
+		return queryParam;
+	}
+
+	if (preQuery && preQuery !== 'null') {
+		return preQuery;
+	}
+
+	return 'No content to display';
+}
+
+const content: Content = await setContent();
+---
+<StudioCMSRenderer {content} />

package/dist/routes/dashboard/studiocms_api/dashboard/partials/UserListItems.astro

@@ -0,0 +1,39 @@
+---
+import UserListItem from '../../../../../components/dashboard/islands/user-mgmt/UserListItem.astro';
+
+export const partial = true;
+
+async function setData() {
+	const jsonData:
+		| {
+				users: {
+					id: string;
+					name: string;
+					email: string | null;
+					avatar: string | null;
+					username: string;
+					permissionsData:
+						| {
+								user: string;
+								rank: string;
+						  }
+						| undefined;
+				}[];
+				searchQuery?: string;
+		  }
+		| undefined = await Astro.request.json();
+
+	if (jsonData) {
+		return jsonData;
+	}
+
+	return 'No Users to display';
+}
+
+const Data = await setData();
+---
+{ 
+	typeof Data !== 'string' 
+	? Data.users.map((user) => <UserListItem user={user} searchQuery={Data.searchQuery} />) 
+	: Data 
+}

package/dist/routes/dashboard/studiocms_api/dashboard/plugins/[plugin].d.ts

@@ -0,0 +1,2 @@
+import type { APIRoute } from 'astro';
+export declare const POST: APIRoute;