ember-repl 5.0.1 → 7.0.0

package/dist/blank-line-Bzg2Qt4K.js

@@ -0,0 +1,482 @@
+import { m as markdownLineEndingOrSpace, u as unicodeWhitespace, a as unicodePunctuation, f as markdownSpace, e as markdownLineEnding } from './index-ZyJlPFQY.js';
+
+/**
+ * Normalize an identifier (as found in references, definitions).
+ *
+ * Collapses markdown whitespace, trim, and then lower- and uppercase.
+ *
+ * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their
+ * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different
+ * uppercase character (U+0398 (`Θ`)).
+ * So, to get a canonical form, we perform both lower- and uppercase.
+ *
+ * Using uppercase last makes sure keys will never interact with default
+ * prototypal values (such as `constructor`): nothing in the prototype of
+ * `Object` is uppercase.
+ *
+ * @param {string} value
+ *   Identifier to normalize.
+ * @returns {string}
+ *   Normalized identifier.
+ */
+function normalizeIdentifier(value) {
+  return value
+  // Collapse markdown whitespace.
+  .replace(/[\t\n\r ]+/g, " ")
+  // Trim.
+  .replace(/^ | $/g, '')
+  // Some characters are considered “uppercase”, but if their lowercase
+  // counterpart is uppercased will result in a different uppercase
+  // character.
+  // Hence, to get that form, we perform both lower- and uppercase.
+  // Upper case makes sure keys will not interact with default prototypal
+  // methods: no method is uppercase.
+  .toLowerCase().toUpperCase();
+}
+
+/**
+ * @import {Code} from 'micromark-util-types'
+ */
+
+/**
+ * Classify whether a code represents whitespace, punctuation, or something
+ * else.
+ *
+ * Used for attention (emphasis, strong), whose sequences can open or close
+ * based on the class of surrounding characters.
+ *
+ * > 👉 **Note**: eof (`null`) is seen as whitespace.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}
+ *   Group.
+ */
+function classifyCharacter(code) {
+  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
+    return 1;
+  }
+  if (unicodePunctuation(code)) {
+    return 2;
+  }
+}
+
+/**
+ * @typedef {import('mdast').Nodes} Nodes
+ *
+ * @typedef Options
+ *   Configuration (optional).
+ * @property {boolean | null | undefined} [includeImageAlt=true]
+ *   Whether to use `alt` for `image`s (default: `true`).
+ * @property {boolean | null | undefined} [includeHtml=true]
+ *   Whether to use `value` of HTML (default: `true`).
+ */
+
+/** @type {Options} */
+const emptyOptions = {};
+
+/**
+ * Get the text content of a node or list of nodes.
+ *
+ * Prefers the node’s plain-text fields, otherwise serializes its children,
+ * and if the given value is an array, serialize the nodes in it.
+ *
+ * @param {unknown} [value]
+ *   Thing to serialize, typically `Node`.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {string}
+ *   Serialized `value`.
+ */
+function toString(value, options) {
+  const settings = emptyOptions;
+  const includeImageAlt = typeof settings.includeImageAlt === 'boolean' ? settings.includeImageAlt : true;
+  const includeHtml = typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true;
+  return one(value, includeImageAlt, includeHtml);
+}
+
+/**
+ * One node or several nodes.
+ *
+ * @param {unknown} value
+ *   Thing to serialize.
+ * @param {boolean} includeImageAlt
+ *   Include image `alt`s.
+ * @param {boolean} includeHtml
+ *   Include HTML.
+ * @returns {string}
+ *   Serialized node.
+ */
+function one(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
+    if ('value' in value) {
+      return value.type === 'html' && !includeHtml ? '' : value.value;
+    }
+    if (includeImageAlt && 'alt' in value && value.alt) {
+      return value.alt;
+    }
+    if ('children' in value) {
+      return all(value.children, includeImageAlt, includeHtml);
+    }
+  }
+  if (Array.isArray(value)) {
+    return all(value, includeImageAlt, includeHtml);
+  }
+  return '';
+}
+
+/**
+ * Serialize a list of nodes.
+ *
+ * @param {Array<unknown>} values
+ *   Thing to serialize.
+ * @param {boolean} includeImageAlt
+ *   Include image `alt`s.
+ * @param {boolean} includeHtml
+ *   Include HTML.
+ * @returns {string}
+ *   Serialized nodes.
+ */
+function all(values, includeImageAlt, includeHtml) {
+  /** @type {Array<string>} */
+  const result = [];
+  let index = -1;
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt, includeHtml);
+  }
+  return result.join('');
+}
+
+/**
+ * Check if `value` looks like a node.
+ *
+ * @param {unknown} value
+ *   Thing.
+ * @returns {value is Nodes}
+ *   Whether `value` is a node.
+ */
+function node(value) {
+  return Boolean(value && typeof value === 'object');
+}
+
+/**
+ * Like `Array#splice`, but smarter for giant arrays.
+ *
+ * `Array#splice` takes all items to be inserted as individual argument which
+ * causes a stack overflow in V8 when trying to insert 100k items for instance.
+ *
+ * Otherwise, this does not return the removed items, and takes `items` as an
+ * array instead of rest parameters.
+ *
+ * @template {unknown} T
+ *   Item type.
+ * @param {Array<T>} list
+ *   List to operate on.
+ * @param {number} start
+ *   Index to remove/insert at (can be negative).
+ * @param {number} remove
+ *   Number of items to remove.
+ * @param {Array<T>} items
+ *   Items to inject into `list`.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function splice(list, start, remove, items) {
+  const end = list.length;
+  let chunkStart = 0;
+  /** @type {Array<unknown>} */
+  let parameters;
+
+  // Make start between zero and `end` (included).
+  if (start < 0) {
+    start = -start > end ? 0 : end + start;
+  } else {
+    start = start > end ? end : start;
+  }
+  remove = remove > 0 ? remove : 0;
+
+  // No need to chunk the items if there’s only a couple (10k) items.
+  if (items.length < 10000) {
+    parameters = Array.from(items);
+    parameters.unshift(start, remove);
+    // @ts-expect-error Hush, it’s fine.
+    list.splice(...parameters);
+  } else {
+    // Delete `remove` items starting from `start`
+    if (remove) list.splice(start, remove);
+
+    // Insert the items in chunks to not cause stack overflows.
+    while (chunkStart < items.length) {
+      parameters = items.slice(chunkStart, chunkStart + 10000);
+      parameters.unshift(start, 0);
+      // @ts-expect-error Hush, it’s fine.
+      list.splice(...parameters);
+      chunkStart += 10000;
+      start += 10000;
+    }
+  }
+}
+
+/**
+ * Append `items` (an array) at the end of `list` (another array).
+ * When `list` was empty, returns `items` instead.
+ *
+ * This prevents a potentially expensive operation when `list` is empty,
+ * and adds items in batches to prevent V8 from hanging.
+ *
+ * @template {unknown} T
+ *   Item type.
+ * @param {Array<T>} list
+ *   List to operate on.
+ * @param {Array<T>} items
+ *   Items to add to `list`.
+ * @returns {Array<T>}
+ *   Either `list` or `items`.
+ */
+function push(list, items) {
+  if (list.length > 0) {
+    splice(list, list.length, 0, items);
+    return list;
+  }
+  return items;
+}
+
+/**
+ * @import {
+ *   Extension,
+ *   Handles,
+ *   HtmlExtension,
+ *   NormalizedExtension
+ * } from 'micromark-util-types'
+ */
+
+const hasOwnProperty = {}.hasOwnProperty;
+
+/**
+ * Combine multiple syntax extensions into one.
+ *
+ * @param {ReadonlyArray<Extension>} extensions
+ *   List of syntax extensions.
+ * @returns {NormalizedExtension}
+ *   A single combined extension.
+ */
+function combineExtensions(extensions) {
+  /** @type {NormalizedExtension} */
+  const all = {};
+  let index = -1;
+  while (++index < extensions.length) {
+    syntaxExtension(all, extensions[index]);
+  }
+  return all;
+}
+
+/**
+ * Merge `extension` into `all`.
+ *
+ * @param {NormalizedExtension} all
+ *   Extension to merge into.
+ * @param {Extension} extension
+ *   Extension to merge.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function syntaxExtension(all, extension) {
+  /** @type {keyof Extension} */
+  let hook;
+  for (hook in extension) {
+    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
+    /** @type {Record<string, unknown>} */
+    const left = maybe || (all[hook] = {});
+    /** @type {Record<string, unknown> | undefined} */
+    const right = extension[hook];
+    /** @type {string} */
+    let code;
+    if (right) {
+      for (code in right) {
+        if (!hasOwnProperty.call(left, code)) left[code] = [];
+        const value = right[code];
+        constructs(
+        // @ts-expect-error Looks like a list.
+        left[code], Array.isArray(value) ? value : value ? [value] : []);
+      }
+    }
+  }
+}
+
+/**
+ * Merge `list` into `existing` (both lists of constructs).
+ * Mutates `existing`.
+ *
+ * @param {Array<unknown>} existing
+ *   List of constructs to merge into.
+ * @param {Array<unknown>} list
+ *   List of constructs to merge.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function constructs(existing, list) {
+  let index = -1;
+  /** @type {Array<unknown>} */
+  const before = [];
+  while (++index < list.length) {
+    (list[index].add === 'after' ? existing : before).push(list[index]);
+  }
+  splice(existing, 0, 0, before);
+}
+
+/**
+ * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'
+ */
+
+/**
+ * Call all `resolveAll`s.
+ *
+ * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs
+ *   List of constructs, optionally with `resolveAll`s.
+ * @param {Array<Event>} events
+ *   List of events.
+ * @param {TokenizeContext} context
+ *   Context used by `tokenize`.
+ * @returns {Array<Event>}
+ *   Changed events.
+ */
+function resolveAll(constructs, events, context) {
+  /** @type {Array<Resolver>} */
+  const called = [];
+  let index = -1;
+  while (++index < constructs.length) {
+    const resolve = constructs[index].resolveAll;
+    if (resolve && !called.includes(resolve)) {
+      events = resolve(events, context);
+      called.push(resolve);
+    }
+  }
+  return events;
+}
+
+/**
+ * @import {Effects, State, TokenType} from 'micromark-util-types'
+ */
+
+
+// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
+
+/**
+ * Parse spaces and tabs.
+ *
+ * There is no `nok` parameter:
+ *
+ * *   spaces in markdown are often optional, in which case this factory can be
+ *     used and `ok` will be switched to whether spaces were found or not
+ * *   one line ending or space can be detected with `markdownSpace(code)` right
+ *     before using `factorySpace`
+ *
+ * ###### Examples
+ *
+ * Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+ * single space.
+ *
+ * ```markdown
+ * ␉
+ * ␠␠␠␠
+ * ␉␠
+ * ```
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {TokenType} type
+ *   Type (`' \t'`).
+ * @param {number | undefined} [max=Infinity]
+ *   Max (exclusive).
+ * @returns {State}
+ *   Start state.
+ */
+function factorySpace(effects, ok, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  let size = 0;
+  return start;
+
+  /** @type {State} */
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code);
+    }
+    return ok(code);
+  }
+
+  /** @type {State} */
+  function prefix(code) {
+    if (markdownSpace(code) && size++ < limit) {
+      effects.consume(code);
+      return prefix;
+    }
+    effects.exit(type);
+    return ok(code);
+  }
+}
+
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+/** @type {Construct} */
+const blankLine = {
+  partial: true,
+  tokenize: tokenizeBlankLine
+};
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeBlankLine(effects, ok, nok) {
+  return start;
+
+  /**
+   * Start of blank line.
+   *
+   * > 👉 **Note**: `␠` represents a space character.
+   *
+   * ```markdown
+   * > | ␠␠␊
+   *     ^
+   * > | ␊
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    return markdownSpace(code) ? factorySpace(effects, after, "linePrefix")(code) : after(code);
+  }
+
+  /**
+   * At eof/eol, after optional whitespace.
+   *
+   * > 👉 **Note**: `␠` represents a space character.
+   *
+   * ```markdown
+   * > | ␠␠␊
+   *       ^
+   * > | ␊
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
+  }
+}
+
+export { combineExtensions as a, blankLine as b, classifyCharacter as c, factorySpace as f, normalizeIdentifier as n, push as p, resolveAll as r, splice as s, toString as t };
+//# sourceMappingURL=blank-line-Bzg2Qt4K.js.map

package/dist/blank-line-Bzg2Qt4K.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blank-line-Bzg2Qt4K.js","sources":["../../../node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.js","../../../node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.js","../../../node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.js","../../../node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.js","../../../node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.js","../../../node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.js","../../../node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js","../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.js"],"sourcesContent":["/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}","/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}","/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["normalizeIdentifier","value","replace","toLowerCase","toUpperCase","classifyCharacter","code","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation","emptyOptions","toString","options","settings","includeImageAlt","includeHtml","one","node","type","alt","all","children","Array","isArray","values","result","index","length","join","Boolean","splice","list","start","remove","items","end","chunkStart","parameters","from","unshift","slice","push","hasOwnProperty","combineExtensions","extensions","syntaxExtension","extension","hook","maybe","call","undefined","left","right","constructs","existing","before","add","resolveAll","events","context","called","resolve","includes","factorySpace","effects","ok","max","limit","Number","POSITIVE_INFINITY","size","markdownSpace","enter","prefix","consume","exit","blankLine","partial","tokenize","tokenizeBlankLine","nok","after","markdownLineEnding"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7]}

package/dist/compile/Compiled.js

@@ -0,0 +1,26 @@
+import { resourceFactory, resource } from 'ember-resources';
+import { getCompiler } from '../services/compiler.js';
+import { compile } from './compile.js';
+
+/**
+ * By default, this compiles to `glimdown`. A Markdown format which
+ * extracts `live` tagged code snippets and compiles them to components.
+ */
+function Compiled(markdownText, maybeFormat, maybeFlavor) {
+  return resource(({
+    owner
+  }) => {
+    const input = typeof markdownText === 'function' ? markdownText() : markdownText;
+    const format = typeof maybeFormat === 'function' ? maybeFormat() : maybeFormat || 'glimdown';
+    const flavor = typeof maybeFlavor === 'function' ? maybeFlavor() : maybeFlavor;
+    const compiler = getCompiler(owner);
+    return compile(compiler, input, {
+      format,
+      flavor
+    });
+  });
+}
+resourceFactory(Compiled);
+
+export { Compiled };
+//# sourceMappingURL=Compiled.js.map

package/dist/compile/Compiled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compiled.js","sources":["../../src/compile/Compiled.ts"],"sourcesContent":["import { resource, resourceFactory } from 'ember-resources';\n\nimport { getCompiler } from '../services/compiler.ts';\nimport { compile } from './compile.ts';\n\nimport type { CompileState } from './state.ts';\nimport type { Format, Input } from './types.ts';\n\nexport function Compiled(markdownText: Input | (() => Input)): CompileState;\nexport function Compiled(\n  markdownText: Input | (() => Input),\n  format?: Format,\n  flavor?: string\n): CompileState;\nexport function Compiled(markdownText: Input | (() => Input), format: () => Format): CompileState;\nexport function Compiled(\n  markdownText: Input | (() => Input),\n  format: () => Format,\n  flavor: () => string\n): CompileState;\n\n/**\n * By default, this compiles to `glimdown`. A Markdown format which\n * extracts `live` tagged code snippets and compiles them to components.\n */\nexport function Compiled(\n  markdownText: Input | (() => Input),\n  maybeFormat?: Format | (() => Format),\n  maybeFlavor?: string | (() => string)\n): CompileState {\n  return resource(({ owner }) => {\n    const input = typeof markdownText === 'function' ? markdownText() : markdownText;\n    const format = typeof maybeFormat === 'function' ? maybeFormat() : maybeFormat || 'glimdown';\n    const flavor = typeof maybeFlavor === 'function' ? maybeFlavor() : maybeFlavor;\n\n    const compiler = getCompiler(owner);\n\n    return compile(compiler, input, {\n      format,\n      flavor,\n    });\n  });\n}\n\nresourceFactory(Compiled);\n"],"names":["Compiled","markdownText","maybeFormat","maybeFlavor","resource","owner","input","format","flavor","compiler","getCompiler","compile","resourceFactory"],"mappings":";;;;AAqBA;AACA;AACA;AACA;AACO,SAASA,QAAQA,CACtBC,YAAmC,EACnCC,WAAqC,EACrCC,WAAqC,EACvB;EACd,OAAOC,QAAQ,CAAC,CAAC;AAAEC,IAAAA;AAAM,GAAC,KAAK;IAC7B,MAAMC,KAAK,GAAG,OAAOL,YAAY,KAAK,UAAU,GAAGA,YAAY,EAAE,GAAGA,YAAY;AAChF,IAAA,MAAMM,MAAM,GAAG,OAAOL,WAAW,KAAK,UAAU,GAAGA,WAAW,EAAE,GAAGA,WAAW,IAAI,UAAU;IAC5F,MAAMM,MAAM,GAAG,OAAOL,WAAW,KAAK,UAAU,GAAGA,WAAW,EAAE,GAAGA,WAAW;AAE9E,IAAA,MAAMM,QAAQ,GAAGC,WAAW,CAACL,KAAK,CAAC;AAEnC,IAAA,OAAOM,OAAO,CAACF,QAAQ,EAAEH,KAAK,EAAE;MAC9BC,MAAM;AACNC,MAAAA;AACF,KAAC,CAAC;AACJ,EAAA,CAAC,CAAC;AACJ;AAEAI,eAAe,CAACZ,QAAQ,CAAC;;;;"}

package/dist/compile/compile.js

@@ -0,0 +1,62 @@
+import { MissingTextState, CompileState, REJECT, RESOLVE } from './state.js';
+import { nameFor } from './utils.js';
+
+const CACHE = new Map();
+function compile(service, text, options) {
+  const data = {
+    format: options.format
+  };
+  if (!text) {
+    return new MissingTextState(data);
+  }
+  const id = nameFor(`${options.format}:${text}`);
+  const state = new CompileState(data);
+
+  // Fills the cache as well
+  runTheCompiler({
+    service,
+    text,
+    options,
+    state,
+    id
+  });
+  return state;
+}
+async function runTheCompiler({
+  service,
+  text,
+  options,
+  state,
+  id
+}) {
+  await options?.onCompileStart?.();
+  await Promise.resolve();
+  if (!text) {
+    state[REJECT](new Error('No Input Document yet'));
+    await options?.onError?.('No Input Document yet');
+    return;
+  }
+  let result;
+
+  // TODO: just use compile, eliminate all this branching
+  if (options.format === 'glimdown') {
+    result = await service.compile('gmd', text, options);
+  } else if (options.format === 'gjs') {
+    result = await service.compileGJS(text);
+  } else if (options.format === 'hbs') {
+    result = await service.compileHBS(text, options);
+  } else {
+    result = await service.compile(options.format, text, options);
+  }
+  if (result.error) {
+    state[REJECT](result.error);
+    await options?.onError?.(state.reason || 'Unknown Error');
+    return;
+  }
+  CACHE.set(id, result.component);
+  state[RESOLVE](result.component);
+  await options?.onSuccess?.(result.component);
+}
+
+export { CACHE, compile };
+//# sourceMappingURL=compile.js.map

package/dist/compile/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sources":["../../src/compile/compile.ts"],"sourcesContent":["import { CompileState, MissingTextState, REJECT, RESOLVE } from './state.ts';\nimport { nameFor } from './utils.ts';\n\nimport type CompilerService from '../services/compiler.ts';\nimport type { CompileResult, Format, Input } from './types.ts';\nimport type { ComponentLike } from '@glint/template';\n\nexport const CACHE = new Map<string, ComponentLike>();\n\ninterface Options {\n  format: Format;\n  flavor?: string;\n  remarkPlugins?: unknown[];\n  rehypePlugins?: unknown[];\n  onSuccess?: (component: ComponentLike) => Promise<unknown> | unknown;\n  onError?: (error: string) => Promise<unknown> | unknown;\n  onCompileStart?: () => Promise<unknown> | unknown;\n}\n\nexport function compile(service: CompilerService, text: Input, options: Options): CompileState {\n  const data = { format: options.format };\n\n  if (!text) {\n    return new MissingTextState(data);\n  }\n\n  const id = nameFor(`${options.format}:${text}`);\n\n  const state = new CompileState(data);\n\n  // Fills the cache as well\n  runTheCompiler({ service, text, options, state, id });\n\n  return state;\n}\n\nasync function runTheCompiler({\n  service,\n  text,\n  options,\n  state,\n  id,\n}: {\n  service: CompilerService;\n  text: string;\n  options: Options;\n  state: CompileState;\n  id: string;\n}) {\n  await options?.onCompileStart?.();\n  await Promise.resolve();\n\n  if (!text) {\n    state[REJECT](new Error('No Input Document yet'));\n    await options?.onError?.('No Input Document yet');\n\n    return;\n  }\n\n  let result: CompileResult;\n\n  // TODO: just use compile, eliminate all this branching\n  if (options.format === 'glimdown') {\n    result = await service.compile('gmd', text, options as any);\n  } else if (options.format === 'gjs') {\n    result = await service.compileGJS(text);\n  } else if (options.format === 'hbs') {\n    result = await service.compileHBS(text, options as any);\n  } else {\n    result = await service.compile(\n      options.format,\n      text,\n      options as unknown as Record<string, unknown>\n    );\n  }\n\n  if (result.error) {\n    state[REJECT](result.error);\n    await options?.onError?.(state.reason || 'Unknown Error');\n\n    return;\n  }\n\n  CACHE.set(id, result.component as ComponentLike);\n\n  state[RESOLVE](result.component as ComponentLike);\n\n  await options?.onSuccess?.(result.component as ComponentLike);\n}\n"],"names":["CACHE","Map","compile","service","text","options","data","format","MissingTextState","id","nameFor","state","CompileState","runTheCompiler","onCompileStart","Promise","resolve","REJECT","Error","onError","result","compileGJS","compileHBS","error","reason","set","component","RESOLVE","onSuccess"],"mappings":";;;MAOaA,KAAK,GAAG,IAAIC,GAAG;AAYrB,SAASC,OAAOA,CAACC,OAAwB,EAAEC,IAAW,EAAEC,OAAgB,EAAgB;AAC7F,EAAA,MAAMC,IAAI,GAAG;IAAEC,MAAM,EAAEF,OAAO,CAACE;GAAQ;EAEvC,IAAI,CAACH,IAAI,EAAE;AACT,IAAA,OAAO,IAAII,gBAAgB,CAACF,IAAI,CAAC;AACnC,EAAA;EAEA,MAAMG,EAAE,GAAGC,OAAO,CAAC,CAAA,EAAGL,OAAO,CAACE,MAAM,CAAA,CAAA,EAAIH,IAAI,CAAA,CAAE,CAAC;AAE/C,EAAA,MAAMO,KAAK,GAAG,IAAIC,YAAY,CAACN,IAAI,CAAC;;AAEpC;AACAO,EAAAA,cAAc,CAAC;IAAEV,OAAO;IAAEC,IAAI;IAAEC,OAAO;IAAEM,KAAK;AAAEF,IAAAA;AAAG,GAAC,CAAC;AAErD,EAAA,OAAOE,KAAK;AACd;AAEA,eAAeE,cAAcA,CAAC;EAC5BV,OAAO;EACPC,IAAI;EACJC,OAAO;EACPM,KAAK;AACLF,EAAAA;AAOF,CAAC,EAAE;AACD,EAAA,MAAMJ,OAAO,EAAES,cAAc,IAAI;AACjC,EAAA,MAAMC,OAAO,CAACC,OAAO,EAAE;EAEvB,IAAI,CAACZ,IAAI,EAAE;IACTO,KAAK,CAACM,MAAM,CAAC,CAAC,IAAIC,KAAK,CAAC,uBAAuB,CAAC,CAAC;AACjD,IAAA,MAAMb,OAAO,EAAEc,OAAO,GAAG,uBAAuB,CAAC;AAEjD,IAAA;AACF,EAAA;AAEA,EAAA,IAAIC,MAAqB;;AAEzB;AACA,EAAA,IAAIf,OAAO,CAACE,MAAM,KAAK,UAAU,EAAE;IACjCa,MAAM,GAAG,MAAMjB,OAAO,CAACD,OAAO,CAAC,KAAK,EAAEE,IAAI,EAAEC,OAAc,CAAC;AAC7D,EAAA,CAAC,MAAM,IAAIA,OAAO,CAACE,MAAM,KAAK,KAAK,EAAE;AACnCa,IAAAA,MAAM,GAAG,MAAMjB,OAAO,CAACkB,UAAU,CAACjB,IAAI,CAAC;AACzC,EAAA,CAAC,MAAM,IAAIC,OAAO,CAACE,MAAM,KAAK,KAAK,EAAE;IACnCa,MAAM,GAAG,MAAMjB,OAAO,CAACmB,UAAU,CAAClB,IAAI,EAAEC,OAAc,CAAC;AACzD,EAAA,CAAC,MAAM;AACLe,IAAAA,MAAM,GAAG,MAAMjB,OAAO,CAACD,OAAO,CAC5BG,OAAO,CAACE,MAAM,EACdH,IAAI,EACJC,OACF,CAAC;AACH,EAAA;EAEA,IAAIe,MAAM,CAACG,KAAK,EAAE;AAChBZ,IAAAA,KAAK,CAACM,MAAM,CAAC,CAACG,MAAM,CAACG,KAAK,CAAC;IAC3B,MAAMlB,OAAO,EAAEc,OAAO,GAAGR,KAAK,CAACa,MAAM,IAAI,eAAe,CAAC;AAEzD,IAAA;AACF,EAAA;EAEAxB,KAAK,CAACyB,GAAG,CAAChB,EAAE,EAAEW,MAAM,CAACM,SAA0B,CAAC;AAEhDf,EAAAA,KAAK,CAACgB,OAAO,CAAC,CAACP,MAAM,CAACM,SAA0B,CAAC;AAEjD,EAAA,MAAMrB,OAAO,EAAEuB,SAAS,GAAGR,MAAM,CAACM,SAA0B,CAAC;AAC/D;;;;"}