@stndrds/schema 1.0.0-alpha.294 → 1.0.0-alpha.296

package/dist/chunk-QT35SI3K.mjs

@@ -1,641 +0,0 @@
-import { ValidationError } from './chunk-CLZORRMS.mjs';
-import { z } from 'zod';
-import { ICONS, COLORS } from '@stndrds/constants';
-
-// src/computed/parser.ts
-var ComputedFormulaParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ComputedFormulaParseError";
-  }
-};
-function parseComputedFormula(expression) {
-  const parser = new Parser(tokenize(expression));
-  const ast = parser.parseExpression();
-  parser.expectEnd();
-  return ast;
-}
-function tokenize(expression) {
-  const tokens = [];
-  let index = 0;
-  while (index < expression.length) {
-    const char = expression[index];
-    if (char === " " || char === "	" || char === "\n" || char === "\r") {
-      index += 1;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      const result = scanString(expression, index, char);
-      tokens.push({ kind: "string", value: result.value, position: index });
-      index = result.nextIndex;
-      continue;
-    }
-    if (isDigit(char)) {
-      const result = scanNumber(expression, index);
-      tokens.push({ kind: "number", value: result.value, position: index });
-      index = result.nextIndex;
-      continue;
-    }
-    if (isIdentifierStart(char)) {
-      const result = scanIdentifier(expression, index);
-      const canonical = result.value.toLowerCase();
-      if (canonical === "true") {
-        tokens.push({ kind: "boolean", value: true, position: index });
-      } else if (canonical === "false") {
-        tokens.push({ kind: "boolean", value: false, position: index });
-      } else if (canonical === "null") {
-        tokens.push({ kind: "null", position: index });
-      } else {
-        tokens.push({ kind: "identifier", value: result.value, position: index });
-      }
-      index = result.nextIndex;
-      continue;
-    }
-    const twoChar = expression.slice(index, index + 2);
-    if (twoChar === ">=" || twoChar === "<=" || twoChar === "==" || twoChar === "!=") {
-      tokens.push({ kind: "operator", value: twoChar, position: index });
-      index += 2;
-      continue;
-    }
-    if (char === ">" || char === "<" || char === "+" || char === "-" || char === "*" || char === "/") {
-      tokens.push({ kind: "operator", value: char, position: index });
-      index += 1;
-      continue;
-    }
-    if (char === "(" || char === ")" || char === "," || char === ".") {
-      tokens.push({ kind: "punctuation", value: char, position: index });
-      index += 1;
-      continue;
-    }
-    throw new ComputedFormulaParseError(`Unexpected character "${char}" at position ${index}`);
-  }
-  return tokens;
-}
-function scanString(expression, startIndex, delimiter = '"') {
-  let value = "";
-  let index = startIndex + 1;
-  while (index < expression.length) {
-    const char = expression[index];
-    if (char === delimiter) {
-      return { value, nextIndex: index + 1 };
-    }
-    if (char === "\\") {
-      const escaped = expression[index + 1];
-      if (escaped === void 0) {
-        throw new ComputedFormulaParseError(`Unterminated string literal at position ${index}`);
-      }
-      value += decodeEscape(escaped, index);
-      index += 2;
-      continue;
-    }
-    value += char;
-    index += 1;
-  }
-  throw new ComputedFormulaParseError(`Unterminated string literal at position ${startIndex}`);
-}
-function decodeEscape(char, position) {
-  switch (char) {
-    case '"':
-    case "\\":
-      return char;
-    case "n":
-      return "\n";
-    case "r":
-      return "\r";
-    case "t":
-      return "	";
-    default:
-      throw new ComputedFormulaParseError(
-        `Unknown escape sequence "\\${char}" at position ${position}`
-      );
-  }
-}
-function scanNumber(expression, startIndex) {
-  let index = startIndex;
-  while (index < expression.length && isDigit(expression[index])) {
-    index += 1;
-  }
-  if (expression[index] === ".") {
-    const decimalStart = index;
-    index += 1;
-    if (!isDigit(expression[index])) {
-      throw new ComputedFormulaParseError(`Invalid number literal at position ${decimalStart}`);
-    }
-    while (index < expression.length && isDigit(expression[index])) {
-      index += 1;
-    }
-  }
-  const raw = expression.slice(startIndex, index);
-  const value = Number(raw);
-  if (!Number.isFinite(value)) {
-    throw new ComputedFormulaParseError(`Invalid number literal "${raw}"`);
-  }
-  return { value, nextIndex: index };
-}
-function scanIdentifier(expression, startIndex) {
-  let index = startIndex + 1;
-  while (index < expression.length && isIdentifierPart(expression[index])) {
-    index += 1;
-  }
-  return { value: expression.slice(startIndex, index), nextIndex: index };
-}
-function isDigit(char) {
-  return char !== void 0 && char >= "0" && char <= "9";
-}
-function isIdentifierStart(char) {
-  return char !== void 0 && /[A-Za-z_]/.test(char);
-}
-function isIdentifierPart(char) {
-  return char !== void 0 && /[A-Za-z0-9_]/.test(char);
-}
-var Parser = class {
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.position = 0;
-  }
-  parseExpression() {
-    return this.parseBinaryExpression(0);
-  }
-  expectEnd() {
-    const token = this.peek();
-    if (token !== void 0) {
-      throw new ComputedFormulaParseError(
-        `Unexpected token ${describeToken(token)} at position ${token.position}`
-      );
-    }
-  }
-  parseBinaryExpression(minPrecedence) {
-    let left = this.parsePrimary();
-    while (true) {
-      const token = this.peek();
-      if (token?.kind !== "operator") {
-        return left;
-      }
-      const precedence = getOperatorPrecedence(token.value);
-      if (precedence < minPrecedence) {
-        return left;
-      }
-      const operator = token.value;
-      this.consume();
-      const right = this.parseBinaryExpression(precedence + 1);
-      left = { kind: "binary", operator, left, right };
-    }
-  }
-  parsePrimary() {
-    const token = this.consume();
-    if (token === void 0) {
-      throw new ComputedFormulaParseError("Unexpected end of expression");
-    }
-    switch (token.kind) {
-      case "string":
-      case "number":
-      case "boolean":
-        return { kind: "literal", value: token.value };
-      case "null":
-        return { kind: "literal", value: null };
-      case "identifier":
-        return this.parseIdentifier(token.value);
-      case "punctuation":
-        if (token.value === "(") {
-          const expression = this.parseExpression();
-          this.expectPunctuation(")");
-          return expression;
-        }
-        break;
-      case "operator":
-        if (token.value === "-") {
-          const next = this.consume();
-          if (next?.kind === "number") {
-            return { kind: "literal", value: -next.value };
-          }
-        }
-        break;
-    }
-    throw new ComputedFormulaParseError(
-      `Expected literal, path, call, or parenthesized expression at position ${token.position}`
-    );
-  }
-  parseIdentifier(identifier) {
-    if (this.matchPunctuation("(")) {
-      const args = [];
-      if (!this.matchPunctuation(")")) {
-        do {
-          args.push(this.parseExpression());
-        } while (this.matchPunctuation(","));
-        this.expectPunctuation(")");
-      }
-      return { kind: "call", functionName: identifier.toLowerCase(), args };
-    }
-    const parts = [identifier];
-    while (this.matchPunctuation(".")) {
-      const next = this.consume();
-      if (next?.kind !== "identifier") {
-        const position = next?.position ?? this.previousPosition();
-        throw new ComputedFormulaParseError(
-          `Expected attribute name after path separator at position ${position}`
-        );
-      }
-      parts.push(next.value);
-    }
-    return { kind: "path", parts };
-  }
-  expectPunctuation(value) {
-    if (!this.matchPunctuation(value)) {
-      const token = this.peek();
-      const position = token?.position ?? this.previousPosition();
-      throw new ComputedFormulaParseError(`Expected "${value}" at position ${position}`);
-    }
-  }
-  matchPunctuation(value) {
-    const token = this.peek();
-    if (token?.kind === "punctuation" && token.value === value) {
-      this.consume();
-      return true;
-    }
-    return false;
-  }
-  peek() {
-    return this.tokens[this.position];
-  }
-  consume() {
-    const token = this.tokens[this.position];
-    this.position += 1;
-    return token;
-  }
-  previousPosition() {
-    const previous = this.tokens[this.position - 1];
-    return previous?.position ?? 0;
-  }
-};
-function describeToken(token) {
-  switch (token.kind) {
-    case "identifier":
-    case "number":
-    case "string":
-    case "boolean":
-    case "operator":
-    case "punctuation":
-      return `"${String(token.value)}"`;
-    case "null":
-      return '"null"';
-    default: {
-      const exhaustive = token;
-      return exhaustive;
-    }
-  }
-}
-function getOperatorPrecedence(operator) {
-  switch (operator) {
-    case "*":
-    case "/":
-      return 3;
-    case "+":
-    case "-":
-      return 2;
-    case ">":
-    case "<":
-    case ">=":
-    case "<=":
-    case "==":
-    case "!=":
-      return 1;
-    default: {
-      const exhaustive = operator;
-      return exhaustive;
-    }
-  }
-}
-
-// src/validation/limits.ts
-var SCHEMA_LIMITS = {
-  attributesPerObject: 300,
-  tabsPerView: 24,
-  groupsPerFormTab: 12,
-  fieldsPerGroup: 60,
-  fieldsPerFormTab: 150,
-  columnsPerTab: 50,
-  optionsPerAttribute: 200,
-  sidePanelAttributes: 100,
-  sidePanelPanes: 20,
-  filterRulesPerTab: 50,
-  sortsPerTab: 20,
-  emailAttributesPerTab: 30,
-  objectsPerPlan: 20,
-  mutationsPerPlan: 500,
-  planBytes: 512 * 1024,
-  historyDefault: 20,
-  historyMax: 50,
-  iconQueries: 5,
-  iconResults: 20
-};
-var COLOR_IDS = Object.keys(COLORS);
-var ICON_NAMES = new Set(ICONS);
-var colorIdSchema = z.enum(COLOR_IDS);
-var iconNameSchema = z.string().superRefine((value, ctx) => {
-  if (!ICON_NAMES.has(value)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Invalid icon name"
-    });
-  }
-}).transform((value) => value);
-
-// src/validation/config/schemas.ts
-var baseConfigSchema = z.object({
-  placeholder: z.string().optional(),
-  description: z.string().optional(),
-  defaultValue: z.unknown().optional(),
-  icon: z.string().optional(),
-  order: z.number().int().optional(),
-  hidden: z.boolean().optional(),
-  archived: z.boolean().optional(),
-  deprecated: z.boolean().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-var optionBaseSchema = z.object({
-  value: z.string().min(1),
-  label: z.string().min(1),
-  description: z.string().optional(),
-  inverse: z.string().optional(),
-  archived: z.boolean().optional()
-});
-var statusGroupSchema = z.enum(["idle", "in_progress", "finished"]);
-var selectOptionWriteSchema = optionBaseSchema.extend({
-  color: colorIdSchema
-}).strict();
-var multiselectOptionWriteSchema = selectOptionWriteSchema;
-var statusOptionWriteSchema = optionBaseSchema.extend({
-  color: colorIdSchema,
-  group: statusGroupSchema
-}).strict();
-var optionSchema = optionBaseSchema.extend({
-  color: z.string().optional(),
-  group: statusGroupSchema.optional()
-}).strict();
-var optionsArraySchema = z.array(optionSchema).min(1).refine(
-  (options) => {
-    const values = options.map((o) => o.value);
-    return new Set(values).size === values.length;
-  },
-  { message: "Duplicate option values are not allowed" }
-);
-function writeOptionsArraySchema(option) {
-  return z.array(option).min(1).max(SCHEMA_LIMITS.optionsPerAttribute).refine(
-    (options) => {
-      const values = options.map((candidate) => candidate.value);
-      return new Set(values).size === values.length;
-    },
-    { message: "Duplicate option values are not allowed" }
-  );
-}
-var selectOptionsWriteSchema = writeOptionsArraySchema(selectOptionWriteSchema);
-var multiselectOptionsWriteSchema = writeOptionsArraySchema(multiselectOptionWriteSchema);
-var statusOptionsWriteSchema = writeOptionsArraySchema(statusOptionWriteSchema);
-var relationTargetSchema = z.object({
-  object: z.string().min(1),
-  displayTemplate: z.string().optional(),
-  filter: z.record(z.string(), z.unknown()).optional()
-});
-var bilateralConfigSchema = z.object({
-  object: z.string().min(1),
-  attribute: z.string().min(1),
-  cardinality: z.enum(["one", "many"]).optional(),
-  storageOwner: z.boolean().optional()
-});
-var computedOptionsSourceSchema = z.object({
-  objectName: z.string().min(1),
-  attributeName: z.string().min(1),
-  attributeId: z.string().optional()
-});
-var textConfigSchema = baseConfigSchema.extend({
-  multiline: z.boolean().optional(),
-  minLength: z.number().int().min(0).optional(),
-  maxLength: z.number().int().min(1).optional(),
-  pattern: z.string().optional(),
-  format: z.enum(["email", "url", "slug"]).optional()
-});
-var richtextConfigSchema = baseConfigSchema;
-var numberConfigSchema = baseConfigSchema.extend({
-  renderAs: z.enum(["number", "rating"]).optional(),
-  min: z.number().optional(),
-  max: z.number().optional(),
-  unit: z.enum(["integer", "decimal", "percentage"]).optional(),
-  decimals: z.number().int().min(0).max(10).optional()
-});
-var checkboxConfigSchema = baseConfigSchema;
-var dateConfigSchema = baseConfigSchema.extend({
-  dateFormat: z.enum(["short", "long", "full", "relative"]).optional(),
-  minDate: z.string().optional(),
-  maxDate: z.string().optional(),
-  includeTime: z.boolean().optional(),
-  endDate: z.boolean().optional(),
-  timeFormat: z.enum(["12h", "24h"]).optional()
-});
-var phoneConfigSchema = baseConfigSchema.extend({
-  defaultCountryCode: z.string().length(3).optional()
-});
-var currencyConfigSchema = baseConfigSchema.extend({
-  defaultCurrency: z.string().length(3).optional(),
-  allowedCurrencies: z.array(z.string().length(3)).optional(),
-  allowNegative: z.boolean().optional()
-});
-var statusConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var locationConfigSchema = baseConfigSchema.extend({
-  granularity: z.enum(["full", "address", "city", "state", "country", "coordinates"]).optional(),
-  defaultCountry: z.string().length(3).optional(),
-  allowedCountries: z.array(z.string().length(3)).optional()
-});
-var selectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema,
-  renderAs: z.literal("badges").optional()
-});
-var multiselectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema,
-  renderAs: z.literal("badges").optional()
-});
-var userConfigSchema = baseConfigSchema.extend({
-  types: z.array(z.enum(["user", "agent"])).min(1).optional(),
-  multiple: z.boolean().optional()
-});
-var relationConfigSchema = baseConfigSchema.extend({
-  targets: z.array(relationTargetSchema).min(1),
-  cardinality: z.enum(["one", "many"]),
-  maxItems: z.number().int().min(1).optional(),
-  bilateral: bilateralConfigSchema.optional(),
-  /**
-   * PropertySchema declared via `.qualifyWith()`. Pass-through; structural
-   * validation happens at the builder level — see `propertySchemaPassthrough`
-   * comment further below for the rationale.
-   */
-  properties: z.object({ definitions: z.array(z.record(z.string(), z.unknown())) }).passthrough().optional()
-});
-var formulaConfigSchema = baseConfigSchema.extend({
-  // Validate the expression grammar up-front so an assignment-style "=" (or any
-  // other malformed syntax) is rejected at save time instead of crashing the
-  // computed write-path later. Type/attribute coherence is still checked
-  // downstream by compileComputedFormula, which needs the full schema.
-  expression: z.string().min(1).superRefine((value, ctx) => {
-    try {
-      parseComputedFormula(value);
-    } catch (error) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: error instanceof Error ? error.message : "Invalid formula expression"
-      });
-    }
-  }),
-  returnType: z.enum(["text", "number", "boolean", "date", "select", "multiselect"]),
-  decimals: z.number().int().min(0).max(10).optional(),
-  allowRelations: z.boolean().optional(),
-  optionsSource: computedOptionsSourceSchema.optional()
-});
-var rollupConfigSchema = baseConfigSchema.extend({
-  relationAttribute: z.string().min(1).optional(),
-  relationPath: z.string().optional(),
-  targetAttribute: z.string().min(1),
-  function: z.enum([
-    "sum",
-    "avg",
-    "earliest",
-    "latest",
-    "count",
-    "countValues",
-    "countUniqueValues",
-    "countEmpty",
-    "percentEmpty",
-    "percentNotEmpty",
-    "original"
-  ]),
-  decimals: z.number().int().min(0).max(10).optional(),
-  targetAttributeType: z.string().optional(),
-  targetAttributeOptions: z.array(optionSchema).optional(),
-  // The sum's symbol (#2644) — declared here or `.strip()` eats it before
-  // storage, exactly the fate this schema spares its two siblings above.
-  targetCurrencyCode: z.string().length(3).optional(),
-  optionsSource: computedOptionsSourceSchema.optional()
-});
-var propertySchemaPassthrough = z.object({ definitions: z.array(z.record(z.string(), z.unknown())) }).passthrough();
-var documentConfigSchema = baseConfigSchema.extend({
-  /**
-   * PropertySchema declared via `.qualifyWith()` on a document attribute.
-   * Drives hydration into `[{id, props}]` shape and write-time validation.
-   */
-  properties: propertySchemaPassthrough.optional(),
-  /** MIME prefixes/globs declared via `.accepts(...)`, applied to every file of the pack. */
-  accepts: z.array(z.string().min(1)).optional(),
-  /** Hard ceiling in bytes declared via `.maxFileSize(...)`, applied to every file of the pack. */
-  maxFileSize: z.number().int().min(1).optional()
-});
-var attributeConfigSchemas = {
-  text: textConfigSchema,
-  richtext: richtextConfigSchema,
-  number: numberConfigSchema,
-  checkbox: checkboxConfigSchema,
-  date: dateConfigSchema,
-  phone: phoneConfigSchema,
-  currency: currencyConfigSchema,
-  status: statusConfigSchema,
-  location: locationConfigSchema,
-  select: selectConfigSchema,
-  multiselect: multiselectConfigSchema,
-  user: userConfigSchema,
-  relation: relationConfigSchema,
-  formula: formulaConfigSchema,
-  rollup: rollupConfigSchema,
-  document: documentConfigSchema
-};
-function getAttributeConfigSchema(type) {
-  const schema = attributeConfigSchemas[type];
-  if (!schema) {
-    throw new ValidationError(`Unsupported attribute type: ${type}`, []);
-  }
-  return schema;
-}
-function parseAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  return schema.strip().parse(config);
-}
-function getAttributeConfigWriteSchema(type) {
-  const schema = getAttributeConfigSchema(type).extend({
-    icon: iconNameSchema.optional()
-  });
-  switch (type) {
-    case "select":
-      return schema.extend({ options: selectOptionsWriteSchema });
-    case "multiselect":
-      return schema.extend({ options: multiselectOptionsWriteSchema });
-    case "status":
-      return schema.extend({ options: statusOptionsWriteSchema });
-    default:
-      return schema;
-  }
-}
-function validationErrorFromIssues(issues) {
-  return ValidationError.fromZodErrors(
-    issues.map((issue) => ({
-      path: issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment),
-      message: issue.message
-    }))
-  );
-}
-function parseWriteSchema(type, input) {
-  const result = getAttributeConfigWriteSchema(type).strip().safeParse(input);
-  if (!result.success) {
-    throw validationErrorFromIssues(result.error.issues);
-  }
-  return result.data;
-}
-function parseAttributeConfigForCreate(type, input) {
-  return parseWriteSchema(type, input);
-}
-function validatePatchedIcon(patch) {
-  if (!Object.prototype.hasOwnProperty.call(patch, "icon")) {
-    return;
-  }
-  const result = iconNameSchema.optional().safeParse(patch.icon);
-  if (!result.success) {
-    throw ValidationError.fromZodErrors(
-      result.error.issues.map((issue) => ({
-        path: [
-          "icon",
-          ...issue.path.map((segment) => typeof segment === "symbol" ? String(segment) : segment)
-        ],
-        message: issue.message
-      }))
-    );
-  }
-}
-function isSelectLike(type) {
-  return type === "select" || type === "multiselect" || type === "status";
-}
-function parseAttributeConfigForUpdate(stored, patch) {
-  const ownsOptions = Object.prototype.hasOwnProperty.call(patch, "options");
-  const ownsIcon = Object.prototype.hasOwnProperty.call(patch, "icon");
-  const input = { ...stored, ...patch };
-  validatePatchedIcon(patch);
-  if (ownsOptions) {
-    const { icon: storedIcon, ...inputWithoutStoredIcon } = input;
-    const parsed2 = parseWriteSchema(stored.type, ownsIcon ? input : inputWithoutStoredIcon);
-    if (!ownsIcon && storedIcon !== void 0) {
-      parsed2.icon = storedIcon;
-    }
-    return parsed2;
-  }
-  const storedOptions = stored.options;
-  if (isSelectLike(stored.type)) {
-    input.options = [{ value: "__legacy__", label: "__legacy__" }];
-  }
-  const result = getAttributeConfigSchema(stored.type).strip().safeParse(input);
-  if (!result.success) {
-    throw validationErrorFromIssues(result.error.issues);
-  }
-  const parsed = result.data;
-  if (isSelectLike(stored.type)) {
-    parsed.options = storedOptions;
-  }
-  return parsed;
-}
-
-export { ComputedFormulaParseError, SCHEMA_LIMITS, attributeConfigSchemas, colorIdSchema, getAttributeConfigSchema, getAttributeConfigWriteSchema, iconNameSchema, multiselectOptionWriteSchema, parseAttributeConfig, parseAttributeConfigForCreate, parseAttributeConfigForUpdate, parseComputedFormula, selectOptionWriteSchema, statusGroupSchema, statusOptionWriteSchema };

package/dist/chunk-QVLQPW3O.mjs

@@ -1,10 +0,0 @@
-import { DEFAULT_VALIDATION_MESSAGES } from './chunk-HRQEZUAA.mjs';
-import { z } from 'zod';
-
-function createRichtextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z.string({
-    message: messages.invalidRichtext(attr)
-  });
-}
-
-export { createRichtextValidator };

package/dist/chunk-QWKLQRBX.js

@@ -1,35 +0,0 @@
-'use strict';
-
-var chunkYKWSHBT5_js = require('./chunk-YKWSHBT5.js');
-var zod = require('zod');
-
-function createSelectValidator(attr, messages = chunkYKWSHBT5_js.DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  if (validValues.length === 0) return zod.z.never();
-  const validLabels = attr.options.map((opt) => opt.label);
-  return zod.z.enum(validValues, {
-    message: messages.invalidOption(attr, validLabels)
-  });
-}
-function createMultiselectValidator(attr, messages = chunkYKWSHBT5_js.DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  if (validValues.length === 0) return zod.z.never();
-  const validLabels = attr.options.map((opt) => opt.label);
-  return zod.z.array(
-    zod.z.enum(validValues, {
-      message: messages.invalidOption(attr, validLabels)
-    })
-  );
-}
-function createStatusValidator(attr, messages = chunkYKWSHBT5_js.DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  if (validValues.length === 0) return zod.z.never();
-  const validLabels = attr.options.map((opt) => opt.label);
-  return zod.z.enum(validValues, {
-    message: messages.invalidOption(attr, validLabels)
-  });
-}
-
-exports.createMultiselectValidator = createMultiselectValidator;
-exports.createSelectValidator = createSelectValidator;
-exports.createStatusValidator = createStatusValidator;