@intellectif/lk-core 0.2.1 → 0.3.1

package/dist/chunk-QOAORTA4.cjs

@@ -0,0 +1,576 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/count-words.ts
+function countWords(text) {
+  if (typeof text !== "string") {
+    return 0;
+  }
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return 0;
+  }
+  return trimmed.split(/\s+/).length;
+}
+
+// src/schemas/feedback.ts
+var _v4 = require('zod/v4');
+var FeedbackSchema = _v4.z.looseObject({
+  correct: _v4.z.string().min(1).optional(),
+  incorrect: _v4.z.string().min(1).optional()
+});
+
+// src/schemas/media.ts
+
+var MediaUrlSchema = _v4.z.union([
+  _v4.z.url().refine((value) => /^(https?|data|blob):/i.test(value), {
+    error: "Absolute media URLs must use the https:, http:, data:, or blob: scheme."
+  }),
+  _v4.z.string().regex(/^\/(?!\/)\S*$/, {
+    error: 'Relative media URLs must be root-relative (a single leading "/").'
+  })
+]);
+var MediaSchema = _v4.z.looseObject({
+  type: _v4.z.enum(["image", "audio", "video", "embed"]),
+  url: MediaUrlSchema,
+  alt: _v4.z.string().min(1).optional(),
+  captionsUrl: MediaUrlSchema.optional()
+}).refine(
+  (m) => m.type !== "image" && m.type !== "embed" || typeof m.alt === "string" && m.alt.length > 0,
+  {
+    error: "image and embed media require non-empty alt text (WCAG 1.1.1 / 4.1.2).",
+    path: ["alt"]
+  }
+).refine((m) => m.type !== "embed" || /^https?:\/\//i.test(m.url), {
+  error: "embed media requires an absolute http(s) provider URL. data:, blob:, and relative URLs are not allowed for embeds \u2014 the embed iframe runs with allow-scripts, and a data:/same-origin document there is an XSS vector.",
+  path: ["url"]
+});
+
+// src/schemas/fill-in-the-blanks.ts
+
+var PLACEHOLDER_RE = /\{\{\s*([^{}]+?)\s*\}\}/g;
+var TextMatchPolicySchema = _v4.z.looseObject({
+  caseSensitive: _v4.z.boolean().optional(),
+  trim: _v4.z.boolean().optional(),
+  normalize: _v4.z.enum(["none", "NFC", "NFKC"]).optional(),
+  foldDiacritics: _v4.z.boolean().optional(),
+  collapseInnerWhitespace: _v4.z.boolean().optional(),
+  ignorePunctuation: _v4.z.boolean().optional(),
+  levenshtein: _v4.z.number().int().min(0).optional(),
+  locale: _v4.z.string().optional()
+});
+var BlankConfigSchema = _v4.z.looseObject({
+  id: _v4.z.string().min(1),
+  acceptedAnswers: _v4.z.array(
+    _v4.z.string().min(1).refine((answer) => answer.trim().length > 0, {
+      error: "Accepted answers must contain non-whitespace characters."
+    })
+  ).min(1),
+  caseSensitive: _v4.z.boolean().optional(),
+  trimWhitespace: _v4.z.boolean().optional(),
+  match: TextMatchPolicySchema.optional(),
+  hint: _v4.z.string().optional(),
+  feedback: _v4.z.string().optional()
+});
+var FillInTheBlanksDataSchema = _v4.z.looseObject({
+  schemaVersion: _v4.z.literal("1.0"),
+  type: _v4.z.literal("fill-in-the-blanks"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  passage: _v4.z.string().min(1),
+  passageHtml: _v4.z.string().optional(),
+  blanks: _v4.z.array(BlankConfigSchema).min(1),
+  scoringStrategy: _v4.z.enum(["all-or-nothing", "partial"]),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: _v4.z.number().min(0).max(1).optional(),
+  locale: _v4.z.string().optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+}).refine(
+  (data) => {
+    const placeholderCounts = /* @__PURE__ */ new Map();
+    for (const match of data.passage.matchAll(PLACEHOLDER_RE)) {
+      const id = match[1];
+      placeholderCounts.set(id, (_nullishCoalesce(placeholderCounts.get(id), () => ( 0))) + 1);
+    }
+    const blankIds = data.blanks.map((blank) => blank.id);
+    if (new Set(blankIds).size !== blankIds.length) {
+      return false;
+    }
+    if (placeholderCounts.size !== blankIds.length) {
+      return false;
+    }
+    return blankIds.every((id) => placeholderCounts.get(id) === 1);
+  },
+  {
+    error: "Each blank id must appear exactly once in blanks[] and have exactly one matching {{id}} placeholder in the passage, and vice versa.",
+    path: ["passage"]
+  }
+);
+
+// src/schemas/multiple-choice.ts
+
+var MultipleChoiceOptionSchema = _v4.z.looseObject({
+  id: _v4.z.string().min(1),
+  text: _v4.z.string().min(1),
+  isCorrect: _v4.z.boolean(),
+  feedback: _v4.z.string().optional()
+});
+var MultipleChoiceDataSchema = _v4.z.looseObject({
+  schemaVersion: _v4.z.literal("1.0"),
+  type: _v4.z.literal("multiple-choice"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  question: _v4.z.string().min(1),
+  questionHtml: _v4.z.string().optional(),
+  mode: _v4.z.enum(["single", "multi"]),
+  options: _v4.z.array(MultipleChoiceOptionSchema).min(2).max(26),
+  scoringStrategy: _v4.z.enum(["all-or-nothing", "partial"]),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: _v4.z.number().min(0).max(1).optional(),
+  shuffle: _v4.z.boolean().optional(),
+  locale: _v4.z.string().optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+}).refine((data) => data.options.some((option) => option.isCorrect), {
+  error: "At least one option must be marked correct.",
+  path: ["options"]
+}).refine(
+  (data) => data.mode !== "single" || data.options.filter((option) => option.isCorrect).length === 1,
+  {
+    error: 'Single-select activities (mode: "single") must have exactly one correct option.',
+    path: ["options"]
+  }
+).refine((data) => new Set(data.options.map((option) => option.id)).size === data.options.length, {
+  error: "Option ids must be unique within the activity.",
+  path: ["options"]
+});
+
+// src/schemas/written-response.ts
+
+var WrittenResponseRubricCriterionSchema = _v4.z.looseObject({
+  name: _v4.z.string().min(1),
+  description: _v4.z.string().optional(),
+  weight: _v4.z.number().min(0)
+});
+var WrittenResponseRubricSchema = _v4.z.looseObject({
+  label: _v4.z.string().optional(),
+  criteria: _v4.z.array(WrittenResponseRubricCriterionSchema).min(1)
+});
+var WrittenResponseDataSchema = _v4.z.looseObject({
+  schemaVersion: _v4.z.literal("1.0"),
+  type: _v4.z.literal("written-response"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  prompt: _v4.z.string(),
+  promptHtml: _v4.z.string().optional(),
+  minWords: _v4.z.number().int().min(0),
+  maxWords: _v4.z.number().int().min(1),
+  rubric: WrittenResponseRubricSchema.optional(),
+  languageTarget: _v4.z.string().optional(),
+  media: MediaSchema.optional(),
+  feedback: FeedbackSchema.optional(),
+  passThreshold: _v4.z.number().min(0).max(1).optional(),
+  locale: _v4.z.string().optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+}).refine((data) => data.maxWords >= data.minWords, {
+  error: "maxWords must be greater than or equal to minWords.",
+  path: ["maxWords"]
+});
+
+// src/schemas/redacted.ts
+
+var redactedBase = {
+  /** Marker distinguishing a redacted projection from full activity data. */
+  redacted: _v4.z.literal(true),
+  schemaVersion: _v4.z.literal("1.0"),
+  id: _v4.z.string().min(1),
+  title: _v4.z.string().min(1),
+  media: MediaSchema.optional(),
+  passThreshold: _v4.z.number().min(0).max(1).optional(),
+  locale: _v4.z.string().optional(),
+  learningObjectives: _v4.z.array(_v4.z.string()).optional(),
+  difficultyLevel: _v4.z.literal([1, 2, 3, 4, 5]).optional()
+};
+var RedactedMultipleChoiceOptionSchema = _v4.z.strictObject({
+  id: _v4.z.string().min(1),
+  text: _v4.z.string().min(1)
+});
+var RedactedMultipleChoiceDataSchema = _v4.z.strictObject({
+  ...redactedBase,
+  type: _v4.z.literal("multiple-choice"),
+  question: _v4.z.string().min(1),
+  questionHtml: _v4.z.string().optional(),
+  mode: _v4.z.enum(["single", "multi"]),
+  options: _v4.z.array(RedactedMultipleChoiceOptionSchema).min(2).max(26),
+  shuffle: _v4.z.boolean().optional()
+});
+var RedactedBlankConfigSchema = _v4.z.strictObject({
+  id: _v4.z.string().min(1),
+  hint: _v4.z.string().optional()
+});
+var RedactedFillInTheBlanksDataSchema = _v4.z.strictObject({
+  ...redactedBase,
+  type: _v4.z.literal("fill-in-the-blanks"),
+  passage: _v4.z.string().min(1),
+  passageHtml: _v4.z.string().optional(),
+  blanks: _v4.z.array(RedactedBlankConfigSchema).min(1)
+});
+var RedactedWrittenResponseDataSchema = _v4.z.strictObject({
+  ...redactedBase,
+  type: _v4.z.literal("written-response"),
+  prompt: _v4.z.string(),
+  promptHtml: _v4.z.string().optional(),
+  minWords: _v4.z.number().int().min(0),
+  maxWords: _v4.z.number().int().min(1),
+  rubric: WrittenResponseRubricSchema.optional(),
+  languageTarget: _v4.z.string().optional()
+});
+
+// src/scoring/text-match.ts
+var COMBINING_MARKS_RE = /\p{M}/gu;
+var PUNCTUATION_RE = /\p{P}/gu;
+function applyBaseline(value, policy) {
+  let result = value;
+  if (policy.trim !== false) {
+    result = result.trim();
+  }
+  if (policy.caseSensitive !== true) {
+    result = policy.locale ? result.toLocaleLowerCase(policy.locale) : result.toLowerCase();
+  }
+  return result;
+}
+function applyNormalization(value, policy) {
+  let result = value;
+  if (policy.normalize === "NFC" || policy.normalize === "NFKC") {
+    result = result.normalize(policy.normalize);
+  }
+  if (policy.ignorePunctuation === true) {
+    result = result.replace(PUNCTUATION_RE, "");
+  }
+  if (policy.collapseInnerWhitespace === true) {
+    result = result.replace(/(?<=\S)\s+(?=\S)/g, " ");
+    if (policy.trim !== false) {
+      result = result.trim();
+    }
+  }
+  return result;
+}
+function applyDiacriticFold(value) {
+  return value.normalize("NFD").replace(COMBINING_MARKS_RE, "").normalize("NFC");
+}
+function levenshteinDistance(a, b, max) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const value = Math.min(
+        previous[j] + 1,
+        current[j - 1] + 1,
+        previous[j - 1] + cost
+      );
+      current.push(value);
+      if (value < rowMin) rowMin = value;
+    }
+    if (rowMin > max) return max + 1;
+    previous = current;
+  }
+  return previous[b.length];
+}
+function matchText(input, accepted, policy = {}) {
+  const acceptedList = typeof accepted === "string" ? [accepted] : accepted;
+  const baselineInput = applyBaseline(input, policy);
+  const baselineAccepted = acceptedList.map((answer) => applyBaseline(answer, policy));
+  if (baselineAccepted.some((answer) => answer === baselineInput)) {
+    return { matched: true, via: "exact" };
+  }
+  const usesNormalization = policy.normalize === "NFC" || policy.normalize === "NFKC" || policy.ignorePunctuation === true || policy.collapseInnerWhitespace === true;
+  const normalizedInput = usesNormalization ? applyNormalization(baselineInput, policy) : baselineInput;
+  const normalizedAccepted = usesNormalization ? baselineAccepted.map((answer) => applyNormalization(answer, policy)) : baselineAccepted;
+  if (usesNormalization && normalizedAccepted.some((answer) => answer === normalizedInput)) {
+    return { matched: true, via: "normalized" };
+  }
+  const foldedInput = policy.foldDiacritics === true ? applyDiacriticFold(normalizedInput) : normalizedInput;
+  const foldedAccepted = policy.foldDiacritics === true ? normalizedAccepted.map((answer) => applyDiacriticFold(answer)) : normalizedAccepted;
+  if (policy.foldDiacritics === true && foldedAccepted.some((answer) => answer === foldedInput)) {
+    return { matched: true, via: "folded" };
+  }
+  const maxDistance = _nullishCoalesce(policy.levenshtein, () => ( 0));
+  if (maxDistance > 0 && foldedAccepted.some(
+    (answer) => levenshteinDistance(foldedInput, answer, maxDistance) <= maxDistance
+  )) {
+    return { matched: true, via: "fuzzy" };
+  }
+  return { matched: false, via: "none" };
+}
+
+// src/registry/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function defineActivityType(descriptor) {
+  return descriptor;
+}
+function registerActivityType(descriptor) {
+  const existing = registry.get(descriptor.type);
+  if (existing !== void 0) {
+    if (existing === descriptor) {
+      return;
+    }
+    throw new Error(
+      `Activity type "${descriptor.type}" is already registered. Registering a different descriptor for an existing type is not allowed.`
+    );
+  }
+  registry.set(descriptor.type, descriptor);
+}
+function getActivityTypeDescriptor(type) {
+  return registry.get(type);
+}
+function registeredActivityTypes() {
+  return [...registry.keys()];
+}
+
+// src/scoring/strategies/all-or-nothing.ts
+function allOrNothingStrategy(correctItems) {
+  return correctItems.every((isCorrect) => isCorrect) ? 1 : 0;
+}
+
+// src/scoring/strategies/partial.ts
+function partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect) {
+  const reward = correctSelected / totalCorrect;
+  const penalty = totalIncorrect === 0 ? 0 : incorrectSelected / totalIncorrect;
+  return Math.max(0, reward - penalty);
+}
+function partialBlankStrategy(correctBlanks, totalBlanks) {
+  return correctBlanks / totalBlanks;
+}
+
+// src/scoring/activity-scorers/fill-in-the-blanks.ts
+function policyFor(blank) {
+  return {
+    ...blank.caseSensitive !== void 0 ? { caseSensitive: blank.caseSensitive } : {},
+    ...blank.trimWhitespace !== void 0 ? { trim: blank.trimWhitespace } : {},
+    ...blank.match
+  };
+}
+function scoreFillInTheBlanks(data, response) {
+  const details = [];
+  const perBlankCorrect = [];
+  for (const blank of data.blanks) {
+    const rawInput = response.answers[blank.id];
+    const input = typeof rawInput === "string" ? rawInput : "";
+    const matched = matchText(input, blank.acceptedAnswers, policyFor(blank)).matched;
+    perBlankCorrect.push(matched);
+    details.push({
+      itemId: blank.id,
+      correct: matched,
+      outcome: matched ? "correct" : "incorrect",
+      learnerResponse: [input],
+      correctResponse: [...blank.acceptedAnswers],
+      weight: 1
+    });
+  }
+  const correctBlanks = perBlankCorrect.filter(Boolean).length;
+  const scoreValue = data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perBlankCorrect) : partialBlankStrategy(correctBlanks, data.blanks.length);
+  return { score: scoreValue, maxScore: 1, feedback: null, details };
+}
+
+// src/scoring/activity-scorers/multiple-choice.ts
+function scoreMultipleChoice(data, response) {
+  const optionById = new Map(data.options.map((option) => [option.id, option]));
+  const selected = new Set(response.selectedOptionIds);
+  const totalCorrect = data.options.filter((option) => option.isCorrect).length;
+  const totalIncorrect = data.options.length - totalCorrect;
+  let scoreValue;
+  if (data.scoringStrategy === "all-or-nothing") {
+    if (data.mode === "single") {
+      scoreValue = response.selectedOptionIds.length === 1 && _optionalChain([optionById, 'access', _2 => _2.get, 'call', _3 => _3(response.selectedOptionIds[0]), 'optionalAccess', _4 => _4.isCorrect]) === true ? 1 : 0;
+    } else {
+      const correctIds = data.options.filter((o) => o.isCorrect).map((o) => o.id);
+      const allCorrectSelected = correctIds.every((id) => selected.has(id));
+      scoreValue = selected.size === correctIds.length && allCorrectSelected ? 1 : 0;
+    }
+  } else {
+    let correctSelected = 0;
+    let incorrectSelected = 0;
+    for (const id of selected) {
+      const option = optionById.get(id);
+      if (_optionalChain([option, 'optionalAccess', _5 => _5.isCorrect])) {
+        correctSelected += 1;
+      } else {
+        incorrectSelected += 1;
+      }
+    }
+    scoreValue = partialStrategy(correctSelected, incorrectSelected, totalCorrect, totalIncorrect);
+  }
+  const details = data.options.map((option) => {
+    const wasSelected = selected.has(option.id);
+    const outcome = wasSelected ? option.isCorrect ? "correct" : "incorrect" : option.isCorrect ? "incorrect-omission" : "correct-omission";
+    return {
+      itemId: option.id,
+      correct: wasSelected === option.isCorrect,
+      outcome,
+      learnerResponse: [wasSelected ? "selected" : "not-selected"],
+      correctResponse: [option.isCorrect ? "selected" : "not-selected"],
+      weight: 1
+    };
+  });
+  return { score: scoreValue, maxScore: 1, feedback: null, details };
+}
+
+// src/registry/builtins.ts
+var SHARED_PUBLIC_FIELDS = {
+  schemaVersion: "public",
+  type: "public",
+  id: "public",
+  title: "public",
+  media: "public",
+  passThreshold: "public",
+  locale: "public",
+  learningObjectives: "public",
+  difficultyLevel: "public"
+};
+var MULTIPLE_CHOICE_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  question: "public",
+  questionHtml: "public",
+  mode: "public",
+  shuffle: "public",
+  scoringStrategy: "answer-key",
+  feedback: "answer-key",
+  options: {
+    id: "public",
+    text: "public",
+    isCorrect: "answer-key",
+    feedback: "answer-key"
+  }
+};
+var FILL_IN_THE_BLANKS_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  passage: "public",
+  passageHtml: "public",
+  scoringStrategy: "answer-key",
+  feedback: "answer-key",
+  blanks: {
+    id: "public",
+    hint: "public",
+    acceptedAnswers: "answer-key",
+    caseSensitive: "answer-key",
+    trimWhitespace: "answer-key",
+    match: "answer-key",
+    feedback: "answer-key"
+  }
+};
+var WRITTEN_RESPONSE_FIELD_POLICY = {
+  ...SHARED_PUBLIC_FIELDS,
+  prompt: "public",
+  promptHtml: "public",
+  minWords: "public",
+  maxWords: "public",
+  languageTarget: "public",
+  feedback: "answer-key",
+  // A rubric is a LEARNER affordance, not a grader secret: it tells the
+  // learner what they are being graded on, which is pedagogically the point
+  // of publishing one. (Classifying it author-only broke real deployments
+  // that render a rubric panel during the attempt.) A deployment that wants
+  // it hidden can tighten this per call via `redact(data, { policy })`.
+  rubric: "public"
+};
+var multipleChoiceType = defineActivityType({
+  type: "multiple-choice",
+  // zod4 optional outputs are `T | undefined`; the hand-written wire types use
+  // exact optionals. Structurally identical at runtime — cast is type-level only.
+  schema: MultipleChoiceDataSchema,
+  scoring: { kind: "sync", score: scoreMultipleChoice },
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _6 => _6.selectedOptionIds, 'access', _7 => _7.length]), () => ( 0))) > 0,
+  fieldPolicy: MULTIPLE_CHOICE_FIELD_POLICY,
+  redactedSchema: RedactedMultipleChoiceDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    xapiInteractionType: "choice",
+    correctResponsesPattern: (data) => [
+      data.options.filter((option) => option.isCorrect).map((option) => option.id).join("[,]")
+    ]
+  },
+  interactions: ["option-selected", "option-deselected", "submitted"]
+});
+var fillInTheBlanksType = defineActivityType({
+  type: "fill-in-the-blanks",
+  schema: FillInTheBlanksDataSchema,
+  scoring: { kind: "sync", score: scoreFillInTheBlanks },
+  isAnswered: (response) => Object.values(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _8 => _8.answers]), () => ( {}))).some((answer) => answer.trim().length > 0),
+  fieldPolicy: FILL_IN_THE_BLANKS_FIELD_POLICY,
+  redactedSchema: RedactedFillInTheBlanksDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    xapiInteractionType: "fill-in",
+    // xAPI fill-in pattern: blank answers joined with "[,]". Only the first
+    // accepted answer per blank is emitted (full alternates would explode
+    // combinatorially); the complete key lives in the activity data.
+    correctResponsesPattern: (data) => [
+      data.blanks.map((blank) => _nullishCoalesce(blank.acceptedAnswers[0], () => ( ""))).join("[,]")
+    ]
+  },
+  interactions: ["blank-filled", "hint-requested", "submitted"]
+});
+var writtenResponseType = defineActivityType({
+  type: "written-response",
+  schema: WrittenResponseDataSchema,
+  scoring: {
+    kind: "deferred",
+    reason: "requires_async_grading",
+    partial: (data, response) => {
+      const wordCount = countWords(_nullishCoalesce(_optionalChain([response, 'optionalAccess', _9 => _9.text]), () => ( "")));
+      return {
+        withinWordBounds: response !== void 0 && wordCount >= data.minWords && wordCount <= data.maxWords,
+        wordCount
+      };
+    }
+  },
+  isAnswered: (response) => (_nullishCoalesce(_optionalChain([response, 'optionalAccess', _10 => _10.text, 'access', _11 => _11.trim, 'call', _12 => _12(), 'access', _13 => _13.length]), () => ( 0))) > 0,
+  fieldPolicy: WRITTEN_RESPONSE_FIELD_POLICY,
+  redactedSchema: RedactedWrittenResponseDataSchema,
+  interop: {
+    xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+    xapiInteractionType: "long-fill-in",
+    correctResponsesPattern: () => []
+  },
+  interactions: ["text-changed", "submitted"]
+});
+registerActivityType(multipleChoiceType);
+registerActivityType(fillInTheBlanksType);
+registerActivityType(writtenResponseType);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.countWords = countWords; exports.FeedbackSchema = FeedbackSchema; exports.MediaUrlSchema = MediaUrlSchema; exports.MediaSchema = MediaSchema; exports.TextMatchPolicySchema = TextMatchPolicySchema; exports.BlankConfigSchema = BlankConfigSchema; exports.FillInTheBlanksDataSchema = FillInTheBlanksDataSchema; exports.MultipleChoiceOptionSchema = MultipleChoiceOptionSchema; exports.MultipleChoiceDataSchema = MultipleChoiceDataSchema; exports.WrittenResponseRubricCriterionSchema = WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = WrittenResponseRubricSchema; exports.WrittenResponseDataSchema = WrittenResponseDataSchema; exports.RedactedMultipleChoiceOptionSchema = RedactedMultipleChoiceOptionSchema; exports.RedactedMultipleChoiceDataSchema = RedactedMultipleChoiceDataSchema; exports.RedactedBlankConfigSchema = RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = RedactedFillInTheBlanksDataSchema; exports.RedactedWrittenResponseDataSchema = RedactedWrittenResponseDataSchema; exports.levenshteinDistance = levenshteinDistance; exports.matchText = matchText; exports.defineActivityType = defineActivityType; exports.registerActivityType = registerActivityType; exports.getActivityTypeDescriptor = getActivityTypeDescriptor; exports.registeredActivityTypes = registeredActivityTypes; exports.multipleChoiceType = multipleChoiceType; exports.fillInTheBlanksType = fillInTheBlanksType; exports.writtenResponseType = writtenResponseType;
+//# sourceMappingURL=chunk-QOAORTA4.cjs.map