ember-repl 6.0.0 → 7.0.0

package/dist/index-ZyJlPFQY.js

@@ -0,0 +1,249 @@
+/**
+ * @import {Code} from 'micromark-util-types'
+ */
+
+/**
+ * Check whether the character code represents an ASCII alpha (`a` through `z`,
+ * case insensitive).
+ *
+ * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+ *
+ * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+ * to U+005A (`Z`).
+ *
+ * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+ * to U+007A (`z`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+const asciiAlpha = regexCheck(/[A-Za-z]/);
+
+/**
+ * Check whether the character code represents an ASCII alphanumeric (`a`
+ * through `z`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+ * (see `asciiAlpha`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+
+/**
+ * Check whether the character code represents an ASCII atext.
+ *
+ * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+ * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+ * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+ * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+ * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+ * (`{`) to U+007E TILDE (`~`).
+ *
+ * See:
+ * **\[RFC5322]**:
+ * [Internet Message Format](https://tools.ietf.org/html/rfc5322).
+ * P. Resnick.
+ * IETF.
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+function asciiControl(code) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    code !== null && (code < 32 || code === 127)
+  );
+}
+
+/**
+ * Check whether the character code represents an ASCII digit (`0` through `9`).
+ *
+ * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+ * U+0039 (`9`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+const asciiDigit = regexCheck(/\d/);
+
+/**
+ * Check whether the character code represents an ASCII hex digit (`a` through
+ * `f`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+ * digit, or an ASCII lower hex digit.
+ *
+ * An **ASCII upper hex digit** is a character in the inclusive range U+0041
+ * (`A`) to U+0046 (`F`).
+ *
+ * An **ASCII lower hex digit** is a character in the inclusive range U+0061
+ * (`a`) to U+0066 (`f`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+const asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+
+/**
+ * Check whether the character code represents ASCII punctuation.
+ *
+ * An **ASCII punctuation** is a character in the inclusive ranges U+0021
+ * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+ * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+ * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+ *
+ * @param code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+function markdownLineEnding(code) {
+  return code !== null && code < -2;
+}
+
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+function markdownLineEndingOrSpace(code) {
+  return code !== null && (code < 0 || code === 32);
+}
+
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ *   Code.
+ * @returns {boolean}
+ *   Whether it matches.
+ */
+function markdownSpace(code) {
+  return code === -2 || code === -1 || code === 32;
+}
+
+// Size note: removing ASCII from the regex and using `asciiPunctuation` here
+// In fact adds to the bundle size.
+/**
+ * Check whether the character code represents Unicode punctuation.
+ *
+ * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+ * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+ * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+ * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+ * punctuation (see `asciiPunctuation`).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+
+/**
+ * Check whether the character code represents Unicode whitespace.
+ *
+ * Note that this does handle micromark specific markdown whitespace characters.
+ * See `markdownLineEndingOrSpace` to check that.
+ *
+ * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+ * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+ * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+const unicodeWhitespace = regexCheck(/\s/);
+
+/**
+ * Create a code check from a regex.
+ *
+ * @param {RegExp} regex
+ *   Expression.
+ * @returns {(code: Code) => boolean}
+ *   Check.
+ */
+function regexCheck(regex) {
+  return check;
+
+  /**
+   * Check whether a code matches the bound regex.
+   *
+   * @param {Code} code
+   *   Character code.
+   * @returns {boolean}
+   *   Whether the character code matches the bound regex.
+   */
+  function check(code) {
+    return code !== null && code > -1 && regex.test(String.fromCharCode(code));
+  }
+}
+
+export { unicodePunctuation as a, asciiAlphanumeric as b, asciiAlpha as c, asciiControl as d, markdownLineEnding as e, markdownSpace as f, asciiAtext as g, asciiPunctuation as h, asciiHexDigit as i, asciiDigit as j, markdownLineEndingOrSpace as m, unicodeWhitespace as u };
+//# sourceMappingURL=index-ZyJlPFQY.js.map

package/dist/index-ZyJlPFQY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-ZyJlPFQY.js","sources":["../../../node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","code","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","check","test","String","fromCharCode"],"mappings":"AAAA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaA,UAAU,GAAGC,UAAU,CAAC,UAAU;;AAE/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaC,iBAAiB,GAAGD,UAAU,CAAC,YAAY;;AAExD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaE,UAAU,GAAGF,UAAU,CAAC,qBAAqB;;AAE1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,YAAYA,CAACC,IAAI,EAAE;AACjC,EAAA;AACE;AACA;IACAA,IAAI,KAAK,IAAI,KAAKA,IAAI,GAAG,EAAE,IAAIA,IAAI,KAAK,GAAG;AAAC;AAEhD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaC,UAAU,GAAGL,UAAU,CAAC,IAAI;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaM,aAAa,GAAGN,UAAU,CAAC,YAAY;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaO,gBAAgB,GAAGP,UAAU,CAAC,gBAAgB;;AAE3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASQ,kBAAkBA,CAACJ,IAAI,EAAE;AACvC,EAAA,OAAOA,IAAI,KAAK,IAAI,IAAIA,IAAI,GAAG,EAAE;AACnC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASK,yBAAyBA,CAACL,IAAI,EAAE;EAC9C,OAAOA,IAAI,KAAK,IAAI,KAAKA,IAAI,GAAG,CAAC,IAAIA,IAAI,KAAK,EAAE,CAAC;AACnD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASM,aAAaA,CAACN,IAAI,EAAE;AAClC,EAAA,OAAOA,IAAI,KAAK,EAAE,IAAIA,IAAI,KAAK,EAAE,IAAIA,IAAI,KAAK,EAAE;AAClD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaO,kBAAkB,GAAGX,UAAU,CAAC,cAAc;;AAE3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACaY,iBAAiB,GAAGZ,UAAU,CAAC,IAAI;;AAEhD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,UAAUA,CAACa,KAAK,EAAE;AACzB,EAAA,OAAOC,KAAK;;AAEZ;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACE,SAASA,KAAKA,CAACV,IAAI,EAAE;AACnB,IAAA,OAAOA,IAAI,KAAK,IAAI,IAAIA,IAAI,GAAG,EAAE,IAAIS,KAAK,CAACE,IAAI,CAACC,MAAM,CAACC,YAAY,CAACb,IAAI,CAAC,CAAC;AAC5E,EAAA;AACF;;;;","x_google_ignoreList":[0]}

package/dist/index-k6CfLgeq.js

@@ -0,0 +1,26 @@
+/**
+ * Count how often a character (or substring) is used in a string.
+ *
+ * @param {string} value
+ *   Value to search in.
+ * @param {string} character
+ *   Character (or substring) to look for.
+ * @return {number}
+ *   Number of times `character` occurred in `value`.
+ */
+function ccount(value, character) {
+  const source = String(value);
+  if (typeof character !== 'string') {
+    throw new TypeError('Expected character');
+  }
+  let count = 0;
+  let index = source.indexOf(character);
+  while (index !== -1) {
+    count++;
+    index = source.indexOf(character, index + character.length);
+  }
+  return count;
+}
+
+export { ccount as c };
+//# sourceMappingURL=index-k6CfLgeq.js.map

package/dist/index-k6CfLgeq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-k6CfLgeq.js","sources":["../../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js"],"sourcesContent":["/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n *   Value to search in.\n * @param {string} character\n *   Character (or substring) to look for.\n * @return {number}\n *   Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n  const source = String(value)\n\n  if (typeof character !== 'string') {\n    throw new TypeError('Expected character')\n  }\n\n  let count = 0\n  let index = source.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = source.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n"],"names":["ccount","value","character","source","String","TypeError","count","index","indexOf","length"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,MAAMA,CAACC,KAAK,EAAEC,SAAS,EAAE;AACvC,EAAA,MAAMC,MAAM,GAAGC,MAAM,CAACH,KAAK,CAAC;AAE5B,EAAA,IAAI,OAAOC,SAAS,KAAK,QAAQ,EAAE;AACjC,IAAA,MAAM,IAAIG,SAAS,CAAC,oBAAoB,CAAC;AAC3C,EAAA;EAEA,IAAIC,KAAK,GAAG,CAAC;AACb,EAAA,IAAIC,KAAK,GAAGJ,MAAM,CAACK,OAAO,CAACN,SAAS,CAAC;AAErC,EAAA,OAAOK,KAAK,KAAK,EAAE,EAAE;AACnBD,IAAAA,KAAK,EAAE;AACPC,IAAAA,KAAK,GAAGJ,MAAM,CAACK,OAAO,CAACN,SAAS,EAAEK,KAAK,GAAGL,SAAS,CAACO,MAAM,CAAC;AAC7D,EAAA;AAEA,EAAA,OAAOH,KAAK;AACd;;;;","x_google_ignoreList":[0]}

package/dist/index.js

@@ -1,3 +1,6 @@
-export { Compiled, compile } from './compile/index.js';
+export { compile } from './compile/compile.js';
+export { Compiled } from './compile/Compiled.js';
 export { invocationName, invocationOf, nameFor } from './compile/utils.js';
+export { getCompiler } from './services/compiler.js';
+export { setup as setupCompiler } from './setup.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/services/compiler.js

@@ -0,0 +1,329 @@
+import { tracked } from '@glimmer/tracking';
+import { setComponentTemplate } from '@ember/component';
+import templateOnly from '@ember/component/template-only';
+import { assert } from '@ember/debug';
+import { registerDestructor } from '@ember/destroyable';
+import { hash, get, fn, concat, array } from '@ember/helper';
+import { on } from '@ember/modifier';
+import { getOwner } from '@ember/owner';
+import { precompileTemplate } from '@ember/template-compilation';
+import { waitFor } from '@ember/test-waiters';
+import { createStore } from 'ember-primitives/store';
+import { resource } from 'ember-resources';
+import { Compiler } from 'repl-sdk';
+import { nameFor } from '../compile/utils.js';
+import { modules } from './known-modules.js';
+import { g, i, n } from 'decorator-transforms/runtime-esm';
+import { v as visit } from '../index-CCcIVEUK.js';
+
+/* eslint-disable getter-return */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+function getCompiler(context) {
+  const owner = getOwner(context) ?? context;
+  assert(`Missing owner. Cannot use ember-repl's compiler without an owner.`, owner);
+  return createStore(owner, CompilerService);
+}
+
+/**
+ * Old way to make static components, because
+ * https://github.com/emberjs/ember.js/issues/20913
+ *
+ * The runtime compiler doesn't allow you to catch compiler errors.
+ * This particular component doesn't need to be runtime anyway.
+ */
+function rendersElement(x) {
+  const render = resource(({
+    on
+  }) => {
+    on.cleanup(() => {
+      x.destroy();
+    });
+    return x.element;
+  });
+  return setComponentTemplate(precompileTemplate(`{{render}}`, {
+    strictMode: true,
+    scope: () => ({
+      render
+    })
+  }), templateOnly());
+}
+/**
+ * Standard for the REPL, not real apps.
+ * HBS isn't used in real apps (that are fully up to date)
+ */
+const standardScope = {
+  // These are only added here because it's convenient for hbs
+  // to have them
+  array,
+  concat,
+  fn,
+  get,
+  hash,
+  on,
+  // The default available scope for gjs:
+  //
+  // We don't use gjs transpilation here, because hbs transpilation
+  // doesn't need to go through the babel infra, so it's faster this way,
+  // even though it's more "verbose" and could get out of sync from the
+  // implementations / source-of-truth.
+  //
+  // https://github.com/emberjs/babel-plugin-ember-template-compilation/blob/main/src/scope-locals.ts#L16
+  //
+  // ////////////////
+  // namespaces
+  // ////////////////
+  //   TC39
+  globalThis,
+  Atomics,
+  JSON,
+  Math,
+  Reflect,
+  //   WHATWG
+  localStorage,
+  sessionStorage,
+  URL,
+  // ////////////////
+  // functions / utilities
+  // ////////////////
+  //   TC39
+  isNaN,
+  isFinite,
+  parseInt,
+  parseFloat,
+  decodeURI,
+  decodeURIComponent,
+  encodeURI,
+  encodeURIComponent,
+  //   WHATWG
+  postMessage,
+  structuredClone,
+  // ////////////////
+  // new-less Constructors (still functions)
+  // ////////////////
+  //   TC39
+  Array,
+  // different behavior from (array)
+  BigInt,
+  Boolean,
+  Date,
+  Number,
+  Object,
+  // different behavior from (hash)
+  String,
+  // ////////////////
+  // Values
+  // ////////////////
+  //   TC39
+  Infinity,
+  NaN,
+  //   WHATWG
+  isSecureContext
+};
+class CompilerService {
+  #compiler;
+  constructor() {
+    const global = getGlobal();
+    global.REPL ||= {};
+    if (global.REPL.compiler) {
+      return global.REPL.compiler;
+    }
+    global.REPL.compiler = this;
+    registerDestructor(this, () => {
+      delete global.REPL?.compiler;
+    });
+  }
+  static {
+    g(this.prototype, "messages", [tracked], function () {
+      return [];
+    });
+  }
+  #messages = (i(this, "messages"), void 0);
+  get lastInfo() {
+    const m = this.messages;
+    for (let i = m.length - 1; i >= 0; i--) {
+      const current = m[i];
+      if (current?.type === 'info') return current;
+    }
+  }
+  get lastError() {
+    const m = this.messages;
+    for (let i = m.length - 1; i >= 0; i--) {
+      const current = m[i];
+      if (current?.type === 'error') return current;
+    }
+  }
+
+  /**
+   * @param {ModuleMap} [ extraModules ]: map of import paths to modules.
+   *  These modules are useful if you need to document a library or a any design system or a styleguide or
+   *  if there are additional modules that could be imported in the passed `code`.
+   * @param {object} [options] optional compiler options for each format/flavor
+   *
+   *  Later on, imports that are not present by default (ember/glimmer) or that
+   *  are not provided by extraModules will be searched on npm to see if a package
+   *  needs to be downloaded before running the `code` / invoking the component
+   */
+  setup = (extraModules = {}, options = {}) => {
+    const localModules = modules(extraModules);
+    this.#compiler = new Compiler({
+      logging: location.search.includes('debug'),
+      resolve: {
+        ...localModules
+      },
+      on: {
+        log: (type, message) => {
+          this.messages.push({
+            type,
+            message
+          });
+          // Waiting on better array primitive
+          // eslint-disable-next-line no-self-assign
+          this.messages = this.messages;
+        }
+      },
+      options: {
+        ...options,
+        gjs: {
+          // owner: getOwner(this),
+          owner: {
+            lookup: () => {},
+            resolveRegistration: () => {}
+          }
+        },
+        gmd: {
+          ...(options.gmd ?? {}),
+          scope: {
+            ...standardScope,
+            ...(options.gmd?.scope ?? {})
+          },
+          remarkPlugins: [function defaultHbsToEmber() {
+            return function transformer(tree) {
+              visit(tree, 'code', node => {
+                if (node.lang === 'hbs') {
+                  if (!node.meta) {
+                    node.meta = 'ember';
+                  } else {
+                    node.meta += ' ember';
+                  }
+                  return node;
+                }
+              });
+              return tree;
+            };
+          }, ...(options.gmd?.remarkPlugins ?? [])]
+        },
+        hbs: {
+          ember: {
+            ...(options.hbs ?? {}),
+            scope: {
+              ...standardScope,
+              ...(options.hbs?.scope ?? {})
+            }
+          }
+        }
+      }
+    });
+  };
+  get compiler() {
+    /**
+     * This is useful for our own testing.
+     * not sure if this would be a footgun for consumers' usage
+     */
+    if (!this.#compiler) {
+      this.setup();
+    }
+    assert(`Expected a compiled to be setup on the compiler service. Use \`compiler.setup()\` first.`, this.#compiler);
+    return this.#compiler;
+  }
+  async createEditor(element, options) {
+    return this.compiler.createEditor(element, options);
+  }
+  async #compile(ext, text, options) {
+    /**
+     * Protect from accidental backtracking-render assertions
+     * (infinite loop protection)
+     *
+     * This function doesn't ready any tracked data, so we don't need to
+     * worry about invalidation or anything.
+     */
+    await Promise.resolve();
+    this.messages = [];
+    return this.compiler.compile(ext, text, options ?? {});
+  }
+
+  /**
+   * @public
+   *
+   * Defers to the underlying repl-SDK and gives us a component we can render.
+   *
+   * @param {string} ext the ext/format to be compiled
+   * @param {string} text the code to be compiled using the configured compiler for the ext
+   */
+  async compile(ext, text, options) {
+    const name = nameFor(text);
+    let component;
+    let error;
+    try {
+      if (ext === 'hbs') {
+        /**
+         * Are there other hbs-using frameworks?
+         */
+        options ||= {};
+        options.flavor = 'ember';
+      }
+      const result = await this.#compile(ext, text, options);
+      component = rendersElement(result);
+    } catch (e) {
+      // Put a breakpoint here to debug
+      // debugger;
+      console.error(e);
+      error = e;
+    }
+    return {
+      name,
+      component,
+      error
+    };
+  }
+
+  /**
+   * @public
+   *
+   * Transpiles GlimmerJS (*.gjs) formatted text into and evaluates as a JS Module.
+   * The returned component can be invoked explicitly in the consuming project.
+   *
+   * @param {string} code the code to be compiled
+   */
+  static {
+    n(this.prototype, "compile", [waitFor]);
+  }
+  compileGJS(code) {
+    return this.compile('gjs', code);
+  }
+
+  /**
+   * compile a template with an empty scope
+   * to use components, helpers, etc, you will need to compile with JS
+   *
+   * (templates alone do not have a way to import / define complex structures)
+   */
+  async compileHBS(source, options = {}) {
+    return this.compile('hbs', source, options);
+  }
+  static {
+    n(this.prototype, "compileHBS", [waitFor]);
+  }
+  compileMD(source, options) {
+    return this.compile('md', source, options);
+  }
+  static {
+    n(this.prototype, "compileMD", [waitFor]);
+  }
+}
+function getGlobal() {
+  return globalThis;
+}
+
+export { CompilerService as default, getCompiler };
+//# sourceMappingURL=compiler.js.map