@qelos/aidev 0.11.0 → 1.0.1

package/ui/.output/server/node_modules/@csstools/css-syntax-patches-for-csstree/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@csstools/css-syntax-patches-for-csstree",
+  "description": "CSS syntax patches for CSS tree",
+  "version": "1.1.4",
+  "contributors": [
+    {
+      "name": "Antonio Laguna",
+      "email": "antonio@laguna.es",
+      "url": "https://antonio.laguna.es"
+    },
+    {
+      "name": "Romain Menke",
+      "email": "romainmenke@gmail.com"
+    }
+  ],
+  "license": "MIT-0",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/csstools"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/csstools"
+    }
+  ],
+  "main": "dist/index.json",
+  "types": "dist/index.d.ts",
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "README.md",
+    "dist"
+  ],
+  "peerDependencies": {
+    "css-tree": "^3.2.1"
+  },
+  "peerDependenciesMeta": {
+    "css-tree": {
+      "optional": true
+    }
+  },
+  "scripts": {},
+  "homepage": "https://github.com/csstools/postcss-plugins/tree/main/packages/css-syntax-patches-for-csstree#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/csstools/postcss-plugins.git",
+    "directory": "packages/css-syntax-patches-for-csstree"
+  },
+  "bugs": "https://github.com/csstools/postcss-plugins/issues",
+  "keywords": [
+    "css",
+    "csstree",
+    "syntax"
+  ]
+}

package/ui/.output/server/node_modules/@csstools/css-tokenizer/dist/index.mjs

@@ -0,0 +1 @@
+class ParseError extends Error{sourceStart;sourceEnd;parserState;constructor(e,n,t,o){super(e),this.name="ParseError",this.sourceStart=n,this.sourceEnd=t,this.parserState=o}}class ParseErrorWithToken extends ParseError{token;constructor(e,n,t,o,r){super(e,n,t,o),this.token=r}}const e={UnexpectedNewLineInString:"Unexpected newline while consuming a string token.",UnexpectedEOFInString:"Unexpected EOF while consuming a string token.",UnexpectedEOFInComment:"Unexpected EOF while consuming a comment.",UnexpectedEOFInURL:"Unexpected EOF while consuming a url token.",UnexpectedEOFInEscapedCodePoint:"Unexpected EOF while consuming an escaped code point.",UnexpectedCharacterInURL:"Unexpected character while consuming a url token.",InvalidEscapeSequenceInURL:"Invalid escape sequence while consuming a url token.",InvalidEscapeSequenceAfterBackslash:'Invalid escape sequence after "\\"'},n="undefined"!=typeof globalThis&&"structuredClone"in globalThis;function cloneTokens(e){return n?structuredClone(e):JSON.parse(JSON.stringify(e))}function stringify(...e){let n="";for(let t=0;t<e.length;t++)n+=e[t][1];return n}const t=13,o=45,r=10,i=43,s=65533;function checkIfFourCodePointsWouldStartCDO(e){return 60===e.source.codePointAt(e.cursor)&&33===e.source.codePointAt(e.cursor+1)&&e.source.codePointAt(e.cursor+2)===o&&e.source.codePointAt(e.cursor+3)===o}function isDigitCodePoint(e){return e>=48&&e<=57}function isUppercaseLetterCodePoint(e){return e>=65&&e<=90}function isLowercaseLetterCodePoint(e){return e>=97&&e<=122}function isHexDigitCodePoint(e){return e>=48&&e<=57||e>=97&&e<=102||e>=65&&e<=70}function isLetterCodePoint(e){return isLowercaseLetterCodePoint(e)||isUppercaseLetterCodePoint(e)}function isIdentStartCodePoint(e){return isLetterCodePoint(e)||isNonASCII_IdentCodePoint(e)||95===e}function isIdentCodePoint(e){return isIdentStartCodePoint(e)||isDigitCodePoint(e)||e===o}function isNonASCII_IdentCodePoint(e){return 183===e||8204===e||8205===e||8255===e||8256===e||8204===e||(192<=e&&e<=214||216<=e&&e<=246||248<=e&&e<=893||895<=e&&e<=8191||8304<=e&&e<=8591||11264<=e&&e<=12271||12289<=e&&e<=55295||63744<=e&&e<=64975||65008<=e&&e<=65533||(0===e||(!!isSurrogate(e)||e>=65536)))}function isNonPrintableCodePoint(e){return 11===e||127===e||0<=e&&e<=8||14<=e&&e<=31}function isNewLine(e){return e===r||e===t||12===e}function isWhitespace(e){return 32===e||e===r||9===e||e===t||12===e}function isSurrogate(e){return e>=55296&&e<=57343}function checkIfTwoCodePointsAreAValidEscape(e){return 92===e.source.codePointAt(e.cursor)&&!isNewLine(e.source.codePointAt(e.cursor+1)??-1)}function checkIfThreeCodePointsWouldStartAnIdentSequence(e,n){return n.source.codePointAt(n.cursor)===o?n.source.codePointAt(n.cursor+1)===o||(!!isIdentStartCodePoint(n.source.codePointAt(n.cursor+1)??-1)||92===n.source.codePointAt(n.cursor+1)&&!isNewLine(n.source.codePointAt(n.cursor+2)??-1)):!!isIdentStartCodePoint(n.source.codePointAt(n.cursor)??-1)||checkIfTwoCodePointsAreAValidEscape(n)}function checkIfThreeCodePointsWouldStartANumber(e){return e.source.codePointAt(e.cursor)===i||e.source.codePointAt(e.cursor)===o?!!isDigitCodePoint(e.source.codePointAt(e.cursor+1)??-1)||46===e.source.codePointAt(e.cursor+1)&&isDigitCodePoint(e.source.codePointAt(e.cursor+2)??-1):46===e.source.codePointAt(e.cursor)?isDigitCodePoint(e.source.codePointAt(e.cursor+1)??-1):isDigitCodePoint(e.source.codePointAt(e.cursor)??-1)}function checkIfTwoCodePointsStartAComment(e){return 47===e.source.codePointAt(e.cursor)&&42===e.source.codePointAt(e.cursor+1)}function checkIfThreeCodePointsWouldStartCDC(e){return e.source.codePointAt(e.cursor)===o&&e.source.codePointAt(e.cursor+1)===o&&62===e.source.codePointAt(e.cursor+2)}var c,a,u;function mirrorVariantType(e){switch(e){case c.OpenParen:return c.CloseParen;case c.CloseParen:return c.OpenParen;case c.OpenCurly:return c.CloseCurly;case c.CloseCurly:return c.OpenCurly;case c.OpenSquare:return c.CloseSquare;case c.CloseSquare:return c.OpenSquare;default:return null}}function mirrorVariant(e){switch(e[0]){case c.OpenParen:return[c.CloseParen,")",-1,-1,void 0];case c.CloseParen:return[c.OpenParen,"(",-1,-1,void 0];case c.OpenCurly:return[c.CloseCurly,"}",-1,-1,void 0];case c.CloseCurly:return[c.OpenCurly,"{",-1,-1,void 0];case c.OpenSquare:return[c.CloseSquare,"]",-1,-1,void 0];case c.CloseSquare:return[c.OpenSquare,"[",-1,-1,void 0];default:return null}}function consumeComment(n,t){for(t.advanceCodePoint(2);;){const o=t.readCodePoint();if(void 0===o){const o=[c.Comment,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,void 0];return n.onParseError(new ParseErrorWithToken(e.UnexpectedEOFInComment,t.representationStart,t.representationEnd,["4.3.2. Consume comments","Unexpected EOF"],o)),o}if(42===o&&(void 0!==t.source.codePointAt(t.cursor)&&47===t.source.codePointAt(t.cursor))){t.advanceCodePoint();break}}return[c.Comment,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,void 0]}function consumeEscapedCodePoint(n,o){const i=o.readCodePoint();if(void 0===i)return n.onParseError(new ParseError(e.UnexpectedEOFInEscapedCodePoint,o.representationStart,o.representationEnd,["4.3.7. Consume an escaped code point","Unexpected EOF"])),s;if(isHexDigitCodePoint(i)){const e=[i];let n;for(;void 0!==(n=o.source.codePointAt(o.cursor))&&isHexDigitCodePoint(n)&&e.length<6;)e.push(n),o.advanceCodePoint();isWhitespace(o.source.codePointAt(o.cursor)??-1)&&(o.source.codePointAt(o.cursor)===t&&o.source.codePointAt(o.cursor+1)===r&&o.advanceCodePoint(),o.advanceCodePoint());const c=parseInt(String.fromCodePoint(...e),16);return 0===c||isSurrogate(c)||c>1114111?s:c}return 0===i||isSurrogate(i)?s:i}function consumeIdentSequence(e,n){const t=[];for(;;){const o=n.source.codePointAt(n.cursor)??-1;if(0===o||isSurrogate(o))t.push(s),n.advanceCodePoint(+(o>65535)+1);else if(isIdentCodePoint(o))t.push(o),n.advanceCodePoint(+(o>65535)+1);else{if(!checkIfTwoCodePointsAreAValidEscape(n))return t;n.advanceCodePoint(),t.push(consumeEscapedCodePoint(e,n))}}}function consumeHashToken(e,n){n.advanceCodePoint();const t=n.source.codePointAt(n.cursor);if(void 0!==t&&(isIdentCodePoint(t)||checkIfTwoCodePointsAreAValidEscape(n))){let t=u.Unrestricted;checkIfThreeCodePointsWouldStartAnIdentSequence(0,n)&&(t=u.ID);const o=consumeIdentSequence(e,n);return[c.Hash,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:String.fromCodePoint(...o),type:t}]}return[c.Delim,"#",n.representationStart,n.representationEnd,{value:"#"}]}function consumeNumber(e,n){let t=a.Integer;for(n.source.codePointAt(n.cursor)!==i&&n.source.codePointAt(n.cursor)!==o||n.advanceCodePoint();isDigitCodePoint(n.source.codePointAt(n.cursor)??-1);)n.advanceCodePoint();if(46===n.source.codePointAt(n.cursor)&&isDigitCodePoint(n.source.codePointAt(n.cursor+1)??-1))for(n.advanceCodePoint(2),t=a.Number;isDigitCodePoint(n.source.codePointAt(n.cursor)??-1);)n.advanceCodePoint();if(101===n.source.codePointAt(n.cursor)||69===n.source.codePointAt(n.cursor)){if(isDigitCodePoint(n.source.codePointAt(n.cursor+1)??-1))n.advanceCodePoint(2);else{if(n.source.codePointAt(n.cursor+1)!==o&&n.source.codePointAt(n.cursor+1)!==i||!isDigitCodePoint(n.source.codePointAt(n.cursor+2)??-1))return t;n.advanceCodePoint(3)}for(t=a.Number;isDigitCodePoint(n.source.codePointAt(n.cursor)??-1);)n.advanceCodePoint()}return t}function consumeNumericToken(e,n){let t;{const e=n.source.codePointAt(n.cursor);e===o?t="-":e===i&&(t="+")}const r=consumeNumber(0,n),s=parseFloat(n.source.slice(n.representationStart,n.representationEnd+1));if(checkIfThreeCodePointsWouldStartAnIdentSequence(0,n)){const o=consumeIdentSequence(e,n);return[c.Dimension,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:s,signCharacter:t,type:r,unit:String.fromCodePoint(...o)}]}return 37===n.source.codePointAt(n.cursor)?(n.advanceCodePoint(),[c.Percentage,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:s,signCharacter:t}]):[c.Number,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:s,signCharacter:t,type:r}]}function consumeWhiteSpace(e){for(;isWhitespace(e.source.codePointAt(e.cursor)??-1);)e.advanceCodePoint();return[c.Whitespace,e.source.slice(e.representationStart,e.representationEnd+1),e.representationStart,e.representationEnd,void 0]}!function(e){e.Comment="comment",e.AtKeyword="at-keyword-token",e.BadString="bad-string-token",e.BadURL="bad-url-token",e.CDC="CDC-token",e.CDO="CDO-token",e.Colon="colon-token",e.Comma="comma-token",e.Delim="delim-token",e.Dimension="dimension-token",e.EOF="EOF-token",e.Function="function-token",e.Hash="hash-token",e.Ident="ident-token",e.Number="number-token",e.Percentage="percentage-token",e.Semicolon="semicolon-token",e.String="string-token",e.URL="url-token",e.Whitespace="whitespace-token",e.OpenParen="(-token",e.CloseParen=")-token",e.OpenSquare="[-token",e.CloseSquare="]-token",e.OpenCurly="{-token",e.CloseCurly="}-token",e.UnicodeRange="unicode-range-token"}(c||(c={})),function(e){e.Integer="integer",e.Number="number"}(a||(a={})),function(e){e.Unrestricted="unrestricted",e.ID="id"}(u||(u={}));class Reader{cursor=0;source="";representationStart=0;representationEnd=-1;constructor(e){this.source=e}advanceCodePoint(e=1){this.cursor=this.cursor+e,this.representationEnd=this.cursor-1}readCodePoint(){const e=this.source.codePointAt(this.cursor);if(void 0!==e)return this.cursor=this.cursor+1,this.representationEnd=this.cursor-1,e}unreadCodePoint(e=1){this.cursor=this.cursor-e,this.representationEnd=this.cursor-1}resetRepresentation(){this.representationStart=this.cursor,this.representationEnd=-1}}function consumeStringToken(n,o){let i="";const a=o.readCodePoint();for(;;){const u=o.readCodePoint();if(void 0===u){const t=[c.String,o.source.slice(o.representationStart,o.representationEnd+1),o.representationStart,o.representationEnd,{value:i}];return n.onParseError(new ParseErrorWithToken(e.UnexpectedEOFInString,o.representationStart,o.representationEnd,["4.3.5. Consume a string token","Unexpected EOF"],t)),t}if(isNewLine(u)){o.unreadCodePoint();const i=[c.BadString,o.source.slice(o.representationStart,o.representationEnd+1),o.representationStart,o.representationEnd,void 0];return n.onParseError(new ParseErrorWithToken(e.UnexpectedNewLineInString,o.representationStart,o.source.codePointAt(o.cursor)===t&&o.source.codePointAt(o.cursor+1)===r?o.representationEnd+2:o.representationEnd+1,["4.3.5. Consume a string token","Unexpected newline"],i)),i}if(u===a)return[c.String,o.source.slice(o.representationStart,o.representationEnd+1),o.representationStart,o.representationEnd,{value:i}];if(92!==u)0===u||isSurrogate(u)?i+=String.fromCodePoint(s):i+=String.fromCodePoint(u);else{if(void 0===o.source.codePointAt(o.cursor))continue;if(isNewLine(o.source.codePointAt(o.cursor)??-1)){o.source.codePointAt(o.cursor)===t&&o.source.codePointAt(o.cursor+1)===r&&o.advanceCodePoint(),o.advanceCodePoint();continue}i+=String.fromCodePoint(consumeEscapedCodePoint(n,o))}}}function checkIfCodePointsMatchURLIdent(e){return!(3!==e.length||117!==e[0]&&85!==e[0]||114!==e[1]&&82!==e[1]||108!==e[2]&&76!==e[2])}function consumeBadURL(e,n){for(;;){const t=n.source.codePointAt(n.cursor);if(void 0===t)return;if(41===t)return void n.advanceCodePoint();checkIfTwoCodePointsAreAValidEscape(n)?(n.advanceCodePoint(),consumeEscapedCodePoint(e,n)):n.advanceCodePoint()}}function consumeUrlToken(n,t){for(;isWhitespace(t.source.codePointAt(t.cursor)??-1);)t.advanceCodePoint();let o="";for(;;){if(void 0===t.source.codePointAt(t.cursor)){const r=[c.URL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,{value:o}];return n.onParseError(new ParseErrorWithToken(e.UnexpectedEOFInURL,t.representationStart,t.representationEnd,["4.3.6. Consume a url token","Unexpected EOF"],r)),r}if(41===t.source.codePointAt(t.cursor))return t.advanceCodePoint(),[c.URL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,{value:o}];if(isWhitespace(t.source.codePointAt(t.cursor)??-1)){for(t.advanceCodePoint();isWhitespace(t.source.codePointAt(t.cursor)??-1);)t.advanceCodePoint();if(void 0===t.source.codePointAt(t.cursor)){const r=[c.URL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,{value:o}];return n.onParseError(new ParseErrorWithToken(e.UnexpectedEOFInURL,t.representationStart,t.representationEnd,["4.3.6. Consume a url token","Consume as much whitespace as possible","Unexpected EOF"],r)),r}return 41===t.source.codePointAt(t.cursor)?(t.advanceCodePoint(),[c.URL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,{value:o}]):(consumeBadURL(n,t),[c.BadURL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,void 0])}const r=t.source.codePointAt(t.cursor);if(34===r||39===r||40===r||isNonPrintableCodePoint(r??-1)){consumeBadURL(n,t);const o=[c.BadURL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,void 0];return n.onParseError(new ParseErrorWithToken(e.UnexpectedCharacterInURL,t.representationStart,t.representationEnd,["4.3.6. Consume a url token","Unexpected U+0022 QUOTATION MARK (\"), U+0027 APOSTROPHE ('), U+0028 LEFT PARENTHESIS (() or non-printable code point"],o)),o}if(92===r){if(checkIfTwoCodePointsAreAValidEscape(t)){t.advanceCodePoint(),o+=String.fromCodePoint(consumeEscapedCodePoint(n,t));continue}consumeBadURL(n,t);const r=[c.BadURL,t.source.slice(t.representationStart,t.representationEnd+1),t.representationStart,t.representationEnd,void 0];return n.onParseError(new ParseErrorWithToken(e.InvalidEscapeSequenceInURL,t.representationStart,t.representationEnd,["4.3.6. Consume a url token","U+005C REVERSE SOLIDUS (\\)","The input stream does not start with a valid escape sequence"],r)),r}0===t.source.codePointAt(t.cursor)||isSurrogate(t.source.codePointAt(t.cursor)??-1)?(o+=String.fromCodePoint(s),t.advanceCodePoint()):(o+=t.source[t.cursor],t.advanceCodePoint())}}function consumeIdentLikeToken(e,n){const t=consumeIdentSequence(e,n);if(40!==n.source.codePointAt(n.cursor))return[c.Ident,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:String.fromCodePoint(...t)}];if(checkIfCodePointsMatchURLIdent(t)){n.advanceCodePoint();let o=0;for(;;){const e=isWhitespace(n.source.codePointAt(n.cursor)??-1),r=isWhitespace(n.source.codePointAt(n.cursor+1)??-1);if(e&&r){o+=1,n.advanceCodePoint(1);continue}const i=e?n.source.codePointAt(n.cursor+1):n.source.codePointAt(n.cursor);if(34===i||39===i)return o>0&&n.unreadCodePoint(o),[c.Function,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:String.fromCodePoint(...t)}];break}return consumeUrlToken(e,n)}return n.advanceCodePoint(),[c.Function,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{value:String.fromCodePoint(...t)}]}function checkIfThreeCodePointsWouldStartAUnicodeRange(e){return!(117!==e.source.codePointAt(e.cursor)&&85!==e.source.codePointAt(e.cursor)||e.source.codePointAt(e.cursor+1)!==i||63!==e.source.codePointAt(e.cursor+2)&&!isHexDigitCodePoint(e.source.codePointAt(e.cursor+2)??-1))}function consumeUnicodeRangeToken(e,n){n.advanceCodePoint(2);const t=[],r=[];let i;for(;void 0!==(i=n.source.codePointAt(n.cursor))&&t.length<6&&isHexDigitCodePoint(i);)t.push(i),n.advanceCodePoint();for(;void 0!==(i=n.source.codePointAt(n.cursor))&&t.length<6&&63===i;)0===r.length&&r.push(...t),t.push(48),r.push(70),n.advanceCodePoint();if(!r.length&&n.source.codePointAt(n.cursor)===o&&isHexDigitCodePoint(n.source.codePointAt(n.cursor+1)??-1))for(n.advanceCodePoint();void 0!==(i=n.source.codePointAt(n.cursor))&&r.length<6&&isHexDigitCodePoint(i);)r.push(i),n.advanceCodePoint();if(!r.length){const e=parseInt(String.fromCodePoint(...t),16);return[c.UnicodeRange,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{startOfRange:e,endOfRange:e}]}const s=parseInt(String.fromCodePoint(...t),16),a=parseInt(String.fromCodePoint(...r),16);return[c.UnicodeRange,n.source.slice(n.representationStart,n.representationEnd+1),n.representationStart,n.representationEnd,{startOfRange:s,endOfRange:a}]}function tokenize(e,n){const t=tokenizer(e,n),o=[];for(;!t.endOfFile();)o.push(t.nextToken());return o.push(t.nextToken()),o}function tokenizer(n,s){const a=n.css.valueOf(),u=n.unicodeRangesAllowed??!1,d=new Reader(a),p={onParseError:s?.onParseError??noop};return{nextToken:function nextToken(){d.resetRepresentation();const n=d.source.codePointAt(d.cursor);if(void 0===n)return[c.EOF,"",-1,-1,void 0];if(47===n&&checkIfTwoCodePointsStartAComment(d))return consumeComment(p,d);if(u&&(117===n||85===n)&&checkIfThreeCodePointsWouldStartAUnicodeRange(d))return consumeUnicodeRangeToken(0,d);if(isIdentStartCodePoint(n))return consumeIdentLikeToken(p,d);if(isDigitCodePoint(n))return consumeNumericToken(p,d);switch(n){case 44:return d.advanceCodePoint(),[c.Comma,",",d.representationStart,d.representationEnd,void 0];case 58:return d.advanceCodePoint(),[c.Colon,":",d.representationStart,d.representationEnd,void 0];case 59:return d.advanceCodePoint(),[c.Semicolon,";",d.representationStart,d.representationEnd,void 0];case 40:return d.advanceCodePoint(),[c.OpenParen,"(",d.representationStart,d.representationEnd,void 0];case 41:return d.advanceCodePoint(),[c.CloseParen,")",d.representationStart,d.representationEnd,void 0];case 91:return d.advanceCodePoint(),[c.OpenSquare,"[",d.representationStart,d.representationEnd,void 0];case 93:return d.advanceCodePoint(),[c.CloseSquare,"]",d.representationStart,d.representationEnd,void 0];case 123:return d.advanceCodePoint(),[c.OpenCurly,"{",d.representationStart,d.representationEnd,void 0];case 125:return d.advanceCodePoint(),[c.CloseCurly,"}",d.representationStart,d.representationEnd,void 0];case 39:case 34:return consumeStringToken(p,d);case 35:return consumeHashToken(p,d);case i:case 46:return checkIfThreeCodePointsWouldStartANumber(d)?consumeNumericToken(p,d):(d.advanceCodePoint(),[c.Delim,d.source[d.representationStart],d.representationStart,d.representationEnd,{value:d.source[d.representationStart]}]);case r:case t:case 12:case 9:case 32:return consumeWhiteSpace(d);case o:return checkIfThreeCodePointsWouldStartANumber(d)?consumeNumericToken(p,d):checkIfThreeCodePointsWouldStartCDC(d)?(d.advanceCodePoint(3),[c.CDC,"--\x3e",d.representationStart,d.representationEnd,void 0]):checkIfThreeCodePointsWouldStartAnIdentSequence(0,d)?consumeIdentLikeToken(p,d):(d.advanceCodePoint(),[c.Delim,"-",d.representationStart,d.representationEnd,{value:"-"}]);case 60:return checkIfFourCodePointsWouldStartCDO(d)?(d.advanceCodePoint(4),[c.CDO,"\x3c!--",d.representationStart,d.representationEnd,void 0]):(d.advanceCodePoint(),[c.Delim,"<",d.representationStart,d.representationEnd,{value:"<"}]);case 64:if(d.advanceCodePoint(),checkIfThreeCodePointsWouldStartAnIdentSequence(0,d)){const e=consumeIdentSequence(p,d);return[c.AtKeyword,d.source.slice(d.representationStart,d.representationEnd+1),d.representationStart,d.representationEnd,{value:String.fromCodePoint(...e)}]}return[c.Delim,"@",d.representationStart,d.representationEnd,{value:"@"}];case 92:{if(checkIfTwoCodePointsAreAValidEscape(d))return consumeIdentLikeToken(p,d);d.advanceCodePoint();const n=[c.Delim,"\\",d.representationStart,d.representationEnd,{value:"\\"}];return p.onParseError(new ParseErrorWithToken(e.InvalidEscapeSequenceAfterBackslash,d.representationStart,d.representationEnd,["4.3.1. Consume a token","U+005C REVERSE SOLIDUS (\\)","The input stream does not start with a valid escape sequence"],n)),n}}return d.advanceCodePoint(),[c.Delim,d.source[d.representationStart],d.representationStart,d.representationEnd,{value:d.source[d.representationStart]}]},endOfFile:function endOfFile(){return void 0===d.source.codePointAt(d.cursor)}}}function noop(){}function mutateIdent(e,n){const t=[];for(const e of n)t.push(e.codePointAt(0));const o=String.fromCodePoint(...serializeIdent(t));e[1]=o,e[4].value=n}function mutateUnit(e,n){const t=[];for(const e of n)t.push(e.codePointAt(0));const o=serializeIdent(t);101===o[0]&&insertEscapedCodePoint(o,0,o[0]);const r=String.fromCodePoint(...o),i="+"===e[4].signCharacter?e[4].signCharacter:"",s=e[4].value.toString();e[1]=`${i}${s}${r}`,e[4].unit=n}function serializeIdent(e){let n=0;if(0===e[0])e.splice(0,1,s),n=1;else if(e[0]===o&&e[1]===o)n=2;else if(e[0]===o&&e[1])n=2,isIdentStartCodePoint(e[1])||(n+=insertEscapedCodePoint(e,1,e[1]));else{if(e[0]===o&&!e[1])return[92,e[0]];isIdentStartCodePoint(e[0])?n=1:(n=1,n+=insertEscapedCodePoint(e,0,e[0]))}for(let t=n;t<e.length;t++)0!==e[t]?isIdentCodePoint(e[t])||(t+=insertEscapedCharacter(e,t,e[t])):(e.splice(t,1,s),t++);return e}function insertEscapedCharacter(e,n,t){return e.splice(n,1,92,t),1}function insertEscapedCodePoint(e,n,t){const o=t.toString(16),r=[];for(const e of o)r.push(e.codePointAt(0));return e.splice(n,1,92,...r,32),1+r.length}const d=Object.values(c);function isToken(e){return!!Array.isArray(e)&&(!(e.length<4)&&(!!d.includes(e[0])&&("string"==typeof e[1]&&("number"==typeof e[2]&&"number"==typeof e[3]))))}function isTokenNumeric(e){if(!e)return!1;switch(e[0]){case c.Dimension:case c.Number:case c.Percentage:return!0;default:return!1}}function isTokenWhiteSpaceOrComment(e){if(!e)return!1;switch(e[0]){case c.Whitespace:case c.Comment:return!0;default:return!1}}function isTokenAtKeyword(e){return!!e&&e[0]===c.AtKeyword}function isTokenBadString(e){return!!e&&e[0]===c.BadString}function isTokenBadURL(e){return!!e&&e[0]===c.BadURL}function isTokenCDC(e){return!!e&&e[0]===c.CDC}function isTokenCDO(e){return!!e&&e[0]===c.CDO}function isTokenColon(e){return!!e&&e[0]===c.Colon}function isTokenComma(e){return!!e&&e[0]===c.Comma}function isTokenComment(e){return!!e&&e[0]===c.Comment}function isTokenDelim(e){return!!e&&e[0]===c.Delim}function isTokenDimension(e){return!!e&&e[0]===c.Dimension}function isTokenEOF(e){return!!e&&e[0]===c.EOF}function isTokenFunction(e){return!!e&&e[0]===c.Function}function isTokenHash(e){return!!e&&e[0]===c.Hash}function isTokenIdent(e){return!!e&&e[0]===c.Ident}function isTokenNumber(e){return!!e&&e[0]===c.Number}function isTokenPercentage(e){return!!e&&e[0]===c.Percentage}function isTokenSemicolon(e){return!!e&&e[0]===c.Semicolon}function isTokenString(e){return!!e&&e[0]===c.String}function isTokenURL(e){return!!e&&e[0]===c.URL}function isTokenWhitespace(e){return!!e&&e[0]===c.Whitespace}function isTokenOpenParen(e){return!!e&&e[0]===c.OpenParen}function isTokenCloseParen(e){return!!e&&e[0]===c.CloseParen}function isTokenOpenSquare(e){return!!e&&e[0]===c.OpenSquare}function isTokenCloseSquare(e){return!!e&&e[0]===c.CloseSquare}function isTokenOpenCurly(e){return!!e&&e[0]===c.OpenCurly}function isTokenCloseCurly(e){return!!e&&e[0]===c.CloseCurly}function isTokenUnicodeRange(e){return!!e&&e[0]===c.UnicodeRange}export{u as HashType,a as NumberType,ParseError,e as ParseErrorMessage,ParseErrorWithToken,c as TokenType,cloneTokens,isToken,isTokenAtKeyword,isTokenBadString,isTokenBadURL,isTokenCDC,isTokenCDO,isTokenCloseCurly,isTokenCloseParen,isTokenCloseSquare,isTokenColon,isTokenComma,isTokenComment,isTokenDelim,isTokenDimension,isTokenEOF,isTokenFunction,isTokenHash,isTokenIdent,isTokenNumber,isTokenNumeric,isTokenOpenCurly,isTokenOpenParen,isTokenOpenSquare,isTokenPercentage,isTokenSemicolon,isTokenString,isTokenURL,isTokenUnicodeRange,isTokenWhiteSpaceOrComment,isTokenWhitespace,mirrorVariant,mirrorVariantType,mutateIdent,mutateUnit,stringify,tokenize,tokenizer};

package/ui/.output/server/node_modules/@csstools/css-tokenizer/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@csstools/css-tokenizer",
+  "description": "Tokenize CSS",
+  "version": "4.0.0",
+  "contributors": [
+    {
+      "name": "Antonio Laguna",
+      "email": "antonio@laguna.es",
+      "url": "https://antonio.laguna.es"
+    },
+    {
+      "name": "Romain Menke",
+      "email": "romainmenke@gmail.com"
+    }
+  ],
+  "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/csstools"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/csstools"
+    }
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "README.md",
+    "dist"
+  ],
+  "scripts": {},
+  "homepage": "https://github.com/csstools/postcss-plugins/tree/main/packages/css-tokenizer#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/csstools/postcss-plugins.git",
+    "directory": "packages/css-tokenizer"
+  },
+  "bugs": "https://github.com/csstools/postcss-plugins/issues",
+  "keywords": [
+    "css",
+    "tokenizer"
+  ]
+}

package/ui/.output/server/node_modules/@exodus/bytes/assert.js

@@ -0,0 +1,26 @@
+export function assertEmptyRest(rest) {
+  if (Object.keys(rest).length > 0) throw new TypeError('Unexpected extra options')
+}
+
+// eslint-disable-next-line sonarjs/no-nested-template-literals
+const makeMessage = (name, extra) => `Expected${name ? ` ${name} to be` : ''} an Uint8Array${extra}`
+
+const TypedArray = Object.getPrototypeOf(Uint8Array)
+
+export function assertTypedArray(arr) {
+  if (arr && arr instanceof TypedArray) return
+  throw new TypeError('Expected a TypedArray instance')
+}
+
+export function assertUint8(arr, options) {
+  if (!options) {
+    // fast path
+    if (arr instanceof Uint8Array) return
+    throw new TypeError('Expected an Uint8Array')
+  }
+
+  const { name, length, ...rest } = options
+  assertEmptyRest(rest)
+  if (arr instanceof Uint8Array && (length === undefined || arr.length === length)) return
+  throw new TypeError(makeMessage(name, length === undefined ? '' : ` of size ${Number(length)}`))
+}

package/ui/.output/server/node_modules/@exodus/bytes/base64.js

@@ -0,0 +1,181 @@
+import { assertEmptyRest } from './assert.js'
+import { assertU8, fromUint8, fromBuffer, E_STRING } from './fallback/_utils.js'
+import { isHermes } from './fallback/platform.js'
+import { decodeLatin1, encodeLatin1 } from './fallback/latin1.js'
+import * as js from './fallback/base64.js'
+
+// See https://datatracker.ietf.org/doc/html/rfc4648
+
+// base64:    A-Za-z0-9+/ and = if padding not disabled
+// base64url: A-Za-z0-9_- and = if padding enabled
+
+const { Buffer, atob, btoa } = globalThis // Buffer is optional, only used when native
+const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
+const { toBase64: web64 } = Uint8Array.prototype // Modern engines have this
+
+const { E_CHAR, E_PADDING, E_LENGTH, E_LAST } = js
+
+// faster only on Hermes (and a little in old Chrome), js path beats it on normal engines
+const shouldUseBtoa = btoa && isHermes
+const shouldUseAtob = atob && isHermes
+
+// For native Buffer codepaths only
+const isBuffer = (x) => x.constructor === Buffer && Buffer.isBuffer(x)
+const toBuffer = (x) => (isBuffer(x) ? x : Buffer.from(x.buffer, x.byteOffset, x.byteLength))
+
+function maybeUnpad(res, padding) {
+  if (padding) return res
+  const at = res.indexOf('=', res.length - 3)
+  return at === -1 ? res : res.slice(0, at)
+}
+
+function maybePad(res, padding) {
+  return padding && res.length % 4 !== 0 ? res + '='.repeat(4 - (res.length % 4)) : res
+}
+
+const toUrl = (x) => x.replaceAll('+', '-').replaceAll('/', '_')
+const haveWeb = (x) => web64 && x.toBase64 === web64
+
+export function toBase64(x, { padding = true } = {}) {
+  assertU8(x)
+  if (haveWeb(x)) return padding ? x.toBase64() : x.toBase64({ omitPadding: !padding }) // Modern, optionless is slightly faster
+  if (haveNativeBuffer) return maybeUnpad(toBuffer(x).base64Slice(0, x.byteLength), padding) // Older Node.js
+  if (shouldUseBtoa) return maybeUnpad(btoa(decodeLatin1(x)), padding)
+  return js.toBase64(x, false, padding) // Fallback
+}
+
+// NOTE: base64url omits padding by default
+export function toBase64url(x, { padding = false } = {}) {
+  assertU8(x)
+  if (haveWeb(x)) return x.toBase64({ alphabet: 'base64url', omitPadding: !padding }) // Modern
+  if (haveNativeBuffer) return maybePad(toBuffer(x).base64urlSlice(0, x.byteLength), padding) // Older Node.js
+  if (shouldUseBtoa) return maybeUnpad(toUrl(btoa(decodeLatin1(x))), padding)
+  return js.toBase64(x, true, padding) // Fallback
+}
+
+// Unlike Buffer.from(), throws on invalid input (non-base64 symbols and incomplete chunks)
+// Unlike Buffer.from() and Uint8Array.fromBase64(), does not allow spaces
+// NOTE: Always operates in strict mode for last chunk
+
+// By default accepts both padded and non-padded variants, only strict base64
+export function fromBase64(str, options) {
+  if (typeof options === 'string') options = { format: options } // Compat due to usage, TODO: remove
+  if (!options) return fromBase64common(str, false, 'both', 'uint8', null)
+  const { format = 'uint8', padding = 'both', ...rest } = options
+  return fromBase64common(str, false, padding, format, rest)
+}
+
+// By default accepts only non-padded strict base64url
+export function fromBase64url(str, options) {
+  if (!options) return fromBase64common(str, true, false, 'uint8', null)
+  const { format = 'uint8', padding = false, ...rest } = options
+  return fromBase64common(str, true, padding, format, rest)
+}
+
+// By default accepts both padded and non-padded variants, base64 or base64url
+export function fromBase64any(str, { format = 'uint8', padding = 'both', ...rest } = {}) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
+  const isBase64url = !str.includes('+') && !str.includes('/') // likely to fail fast, as most input is non-url, also double scan is faster than regex
+  return fromBase64common(str, isBase64url, padding, format, rest)
+}
+
+function fromBase64common(str, isBase64url, padding, format, rest) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
+  if (rest !== null) assertEmptyRest(rest)
+  const auto = padding === 'both' ? str.endsWith('=') : undefined
+  // Older JSC supporting Uint8Array.fromBase64 lacks proper checks
+  if (padding === true || auto === true) {
+    if (str.length % 4 !== 0) throw new SyntaxError(E_PADDING) // JSC misses this
+    if (str[str.length - 3] === '=') throw new SyntaxError(E_PADDING) // no more than two = at the end
+  } else if (padding === false || auto === false) {
+    if (str.length % 4 === 1) throw new SyntaxError(E_LENGTH) // JSC misses this in fromBase64
+    if (padding === false && str.endsWith('=')) {
+      throw new SyntaxError('Did not expect padding in base64 input') // inclusion is checked separately
+    }
+  } else {
+    throw new TypeError('Invalid padding option')
+  }
+
+  return fromBase64impl(str, isBase64url, padding, format)
+}
+
+// ASCII whitespace is U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or U+0020 SPACE
+const ASCII_WHITESPACE = /[\t\n\f\r ]/ // non-u for JSC perf
+
+function noWhitespaceSeen(str, arr) {
+  const at = str.indexOf('=', str.length - 3)
+  const paddingLength = at >= 0 ? str.length - at : 0
+  const chars = str.length - paddingLength
+  const e = chars % 4 // extra chars past blocks of 4
+  const b = arr.length - ((chars - e) / 4) * 3 // remaining bytes not covered by full blocks of chars
+  return (e === 0 && b === 0) || (e === 2 && b === 1) || (e === 3 && b === 2)
+}
+
+let fromBase64impl
+if (Uint8Array.fromBase64) {
+  // NOTICE: this is actually slower than our JS impl in older JavaScriptCore and (slightly) in SpiderMonkey, but faster on V8 and new JavaScriptCore
+  fromBase64impl = (str, isBase64url, padding, format) => {
+    const alphabet = isBase64url ? 'base64url' : 'base64'
+
+    let arr
+    if (padding === true) {
+      // Padding is required from user, and we already checked that string length is divisible by 4
+      // Padding might still be wrong due to whitespace, but in that case native impl throws expected error
+      arr = Uint8Array.fromBase64(str, { alphabet, lastChunkHandling: 'strict' })
+    } else {
+      try {
+        const padded = str.length % 4 > 0 ? `${str}${'='.repeat(4 - (str.length % 4))}` : str
+        arr = Uint8Array.fromBase64(padded, { alphabet, lastChunkHandling: 'strict' })
+      } catch (err) {
+        // Normalize error: whitespace in input could have caused added padding to be invalid
+        // But reporting that as a padding error would be confusing
+        throw ASCII_WHITESPACE.test(str) ? new SyntaxError(E_CHAR) : err
+      }
+    }
+
+    // We don't allow whitespace in input, but that can be rechecked based on output length
+    // All other chars are checked natively
+    if (!noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR)
+    return fromUint8(arr, format)
+  }
+} else if (haveNativeBuffer) {
+  fromBase64impl = (str, isBase64url, padding, format) => {
+    const size = Buffer.byteLength(str, 'base64')
+    const arr = Buffer.allocUnsafeSlow(size) // non-pooled
+    if (arr.base64Write(str) !== size) throw new SyntaxError(E_PADDING)
+    // Rechecking by re-encoding is cheaper than regexes on Node.js
+    const got = isBase64url ? maybeUnpad(str, padding === false) : maybePad(str, padding !== true)
+    const valid = isBase64url ? arr.base64urlSlice(0, arr.length) : arr.base64Slice(0, arr.length)
+    if (got !== valid) throw new SyntaxError(E_PADDING)
+    return fromBuffer(arr, format) // fully checked
+  }
+} else if (shouldUseAtob) {
+  // atob is faster than manual parsing on Hermes
+  fromBase64impl = (str, isBase64url, padding, format) => {
+    let arr
+    if (isBase64url) {
+      if (/[\t\n\f\r +/]/.test(str)) throw new SyntaxError(E_CHAR) // atob verifies other invalid input
+      str = str.replaceAll('-', '+').replaceAll('_', '/') // from url to normal
+    }
+
+    try {
+      arr = encodeLatin1(atob(str))
+    } catch {
+      throw new SyntaxError(E_CHAR) // convert atob errors
+    }
+
+    if (!isBase64url && !noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR) // base64url checks input above
+
+    if (arr.length % 3 !== 0) {
+      // Check last chunk to be strict if it was incomplete
+      const expected = toBase64(arr.subarray(-(arr.length % 3))) // str is normalized to non-url already
+      const end = str.length % 4 === 0 ? str.slice(-4) : str.slice(-(str.length % 4)).padEnd(4, '=')
+      if (expected !== end) throw new SyntaxError(E_LAST)
+    }
+
+    return fromUint8(arr, format)
+  }
+} else {
+  fromBase64impl = (str, isBase64url, padding, format) =>
+    fromUint8(js.fromBase64(str, isBase64url), format) // validated in js
+}

package/ui/.output/server/node_modules/@exodus/bytes/encoding-lite.js

@@ -0,0 +1,12 @@
+export {
+  TextDecoder,
+  TextEncoder,
+  TextDecoderStream,
+  TextEncoderStream,
+  normalizeEncoding,
+  getBOMEncoding,
+  labelToName,
+  legacyHookDecode,
+  isomorphicDecode,
+  isomorphicEncode,
+} from './fallback/encoding.js'

package/ui/.output/server/node_modules/@exodus/bytes/encoding.js

@@ -0,0 +1,18 @@
+import { createMultibyteDecoder } from '@exodus/bytes/multi-byte.js'
+import { multibyteEncoder } from './fallback/multi-byte.js'
+import { setMultibyte } from './fallback/encoding.js'
+
+setMultibyte(createMultibyteDecoder, multibyteEncoder)
+
+export {
+  TextDecoder,
+  TextEncoder,
+  TextDecoderStream,
+  TextEncoderStream,
+  normalizeEncoding,
+  getBOMEncoding,
+  labelToName,
+  legacyHookDecode,
+  isomorphicDecode,
+  isomorphicEncode,
+} from './fallback/encoding.js'

package/ui/.output/server/node_modules/@exodus/bytes/fallback/_utils.js

@@ -0,0 +1,60 @@
+export * from './platform.js'
+
+const Buffer = /* @__PURE__ */ (() => globalThis.Buffer)()
+
+export function assert(condition, msg) {
+  if (!condition) throw new Error(msg)
+}
+
+export function assertU8(arg) {
+  if (arg && arg instanceof Uint8Array) return
+  throw new TypeError('Expected an Uint8Array')
+}
+
+// On arrays in heap (<= 64) it's cheaper to copy into a pooled buffer than lazy-create the ArrayBuffer storage
+export const toBuf = (x) =>
+  x.byteLength <= 64 && x.BYTES_PER_ELEMENT === 1
+    ? Buffer.from(x)
+    : Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+
+export const E_STRING = 'Input is not a string'
+export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
+
+// Input is never pooled
+export function fromUint8(arr, format) {
+  switch (format) {
+    case 'uint8':
+      if (arr.constructor !== Uint8Array) throw new Error('Unexpected')
+      return arr
+    case 'arraybuffer':
+      if (arr.byteLength !== arr.buffer.byteLength) throw new Error('Unexpected')
+      return arr.buffer
+    case 'buffer':
+      if (arr.length <= 64) return Buffer.from(arr)
+      return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength)
+  }
+
+  throw new TypeError('Unexpected format')
+}
+
+// Input can be pooled
+export function fromBuffer(arr, format) {
+  switch (format) {
+    case 'uint8':
+      // byteOffset check is slightly faster and covers most pooling, so it comes first
+      if (arr.length <= 64 || arr.byteOffset !== 0 || arr.byteLength !== arr.buffer.byteLength) {
+        return new Uint8Array(arr)
+      }
+
+      return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+    case 'arraybuffer':
+      return arr.buffer.byteLength === arr.byteLength
+        ? arr.buffer
+        : arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength)
+    case 'buffer':
+      if (arr.constructor !== Buffer) throw new Error('Unexpected')
+      return arr
+  }
+
+  throw new TypeError('Unexpected format')
+}

package/ui/.output/server/node_modules/@exodus/bytes/fallback/base64.js

@@ -0,0 +1,191 @@
+import { nativeEncoder, nativeDecoder } from './platform.js'
+import { encodeAscii, decodeAscii } from './latin1.js'
+
+// See https://datatracker.ietf.org/doc/html/rfc4648
+
+const BASE64 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/']
+const BASE64URL = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_']
+const BASE64_HELPERS = {}
+const BASE64URL_HELPERS = {}
+
+export const E_CHAR = 'Invalid character in base64 input'
+export const E_PADDING = 'Invalid base64 padding'
+export const E_LENGTH = 'Invalid base64 length'
+export const E_LAST = 'Invalid last chunk'
+
+// We construct output by concatenating chars, this seems to be fine enough on modern JS engines
+// Expects a checked Uint8Array
+export function toBase64(arr, isURL, padding) {
+  const fullChunks = (arr.length / 3) | 0
+  const fullChunksBytes = fullChunks * 3
+  let o = ''
+  let i = 0
+
+  const alphabet = isURL ? BASE64URL : BASE64
+  const helpers = isURL ? BASE64URL_HELPERS : BASE64_HELPERS
+  if (!helpers.pairs) {
+    helpers.pairs = []
+    if (nativeDecoder) {
+      // Lazy to save memory in case if this is not needed
+      helpers.codepairs = new Uint16Array(64 * 64)
+      const u16 = helpers.codepairs
+      const u8 = new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength) // write as 1-byte to ignore BE/LE difference
+      for (let i = 0; i < 64; i++) {
+        const ic = alphabet[i].charCodeAt(0)
+        for (let j = 0; j < 64; j++) u8[(i << 7) | (j << 1)] = u8[(j << 7) | ((i << 1) + 1)] = ic
+      }
+    } else {
+      const p = helpers.pairs
+      for (let i = 0; i < 64; i++) {
+        for (let j = 0; j < 64; j++) p.push(`${alphabet[i]}${alphabet[j]}`)
+      }
+    }
+  }
+
+  const { pairs, codepairs } = helpers
+
+  // Fast path for complete blocks
+  // This whole loop can be commented out, the algorithm won't change, it's just an optimization of the next loop
+  if (nativeDecoder) {
+    const oa = new Uint16Array(fullChunks * 2)
+    let j = 0
+    for (const last = arr.length - 11; i < last; i += 12, j += 8) {
+      const x0 = arr[i]
+      const x1 = arr[i + 1]
+      const x2 = arr[i + 2]
+      const x3 = arr[i + 3]
+      const x4 = arr[i + 4]
+      const x5 = arr[i + 5]
+      const x6 = arr[i + 6]
+      const x7 = arr[i + 7]
+      const x8 = arr[i + 8]
+      const x9 = arr[i + 9]
+      const x10 = arr[i + 10]
+      const x11 = arr[i + 11]
+      oa[j] = codepairs[(x0 << 4) | (x1 >> 4)]
+      oa[j + 1] = codepairs[((x1 & 0x0f) << 8) | x2]
+      oa[j + 2] = codepairs[(x3 << 4) | (x4 >> 4)]
+      oa[j + 3] = codepairs[((x4 & 0x0f) << 8) | x5]
+      oa[j + 4] = codepairs[(x6 << 4) | (x7 >> 4)]
+      oa[j + 5] = codepairs[((x7 & 0x0f) << 8) | x8]
+      oa[j + 6] = codepairs[(x9 << 4) | (x10 >> 4)]
+      oa[j + 7] = codepairs[((x10 & 0x0f) << 8) | x11]
+    }
+
+    // i < last here is equivalent to i < fullChunksBytes
+    for (const last = arr.length - 2; i < last; i += 3, j += 2) {
+      const a = arr[i]
+      const b = arr[i + 1]
+      const c = arr[i + 2]
+      oa[j] = codepairs[(a << 4) | (b >> 4)]
+      oa[j + 1] = codepairs[((b & 0x0f) << 8) | c]
+    }
+
+    o = decodeAscii(oa)
+  } else {
+    // This can be optimized by ~25% with templates on Hermes, but this codepath is not called on Hermes, it uses btoa
+    // Check git history for templates version
+    for (; i < fullChunksBytes; i += 3) {
+      const a = arr[i]
+      const b = arr[i + 1]
+      const c = arr[i + 2]
+      o += pairs[(a << 4) | (b >> 4)]
+      o += pairs[((b & 0x0f) << 8) | c]
+    }
+  }
+
+  // If we have something left, process it with a full algo
+  let carry = 0
+  let shift = 2 // First byte needs to be shifted by 2 to get 6 bits
+  const length = arr.length
+  for (; i < length; i++) {
+    const x = arr[i]
+    o += alphabet[carry | (x >> shift)] // shift >= 2, so this fits
+    if (shift === 6) {
+      shift = 0
+      o += alphabet[x & 0x3f]
+    }
+
+    carry = (x << (6 - shift)) & 0x3f
+    shift += 2 // Each byte prints 6 bits and leaves 2 bits
+  }
+
+  if (shift !== 2) o += alphabet[carry] // shift 2 means we have no carry left
+  if (padding) o += ['', '==', '='][length - fullChunksBytes]
+
+  return o
+}
+
+// TODO: can this be optimized? This only affects non-Hermes barebone engines though
+const mapSize = nativeEncoder ? 128 : 65_536 // we have to store 64 KiB map or recheck everything if we can't decode to byte array
+
+export function fromBase64(str, isURL) {
+  let inputLength = str.length
+  while (str[inputLength - 1] === '=') inputLength--
+  const paddingLength = str.length - inputLength
+  const tailLength = inputLength % 4
+  const mainLength = inputLength - tailLength // multiples of 4
+  if (tailLength === 1) throw new SyntaxError(E_LENGTH)
+  if (paddingLength > 3 || (paddingLength !== 0 && str.length % 4 !== 0)) {
+    throw new SyntaxError(E_PADDING)
+  }
+
+  const alphabet = isURL ? BASE64URL : BASE64
+  const helpers = isURL ? BASE64URL_HELPERS : BASE64_HELPERS
+
+  if (!helpers.fromMap) {
+    helpers.fromMap = new Int8Array(mapSize).fill(-1) // no regex input validation here, so we map all other bytes to -1 and recheck sign
+    alphabet.forEach((c, i) => (helpers.fromMap[c.charCodeAt(0)] = i))
+  }
+
+  const m = helpers.fromMap
+
+  const arr = new Uint8Array(Math.floor((inputLength * 3) / 4))
+  let at = 0
+  let i = 0
+
+  if (nativeEncoder) {
+    const codes = encodeAscii(str, E_CHAR)
+    for (; i < mainLength; i += 4) {
+      const c0 = codes[i]
+      const c1 = codes[i + 1]
+      const c2 = codes[i + 2]
+      const c3 = codes[i + 3]
+      const a = (m[c0] << 18) | (m[c1] << 12) | (m[c2] << 6) | m[c3]
+      if (a < 0) throw new SyntaxError(E_CHAR)
+      arr[at] = a >> 16
+      arr[at + 1] = (a >> 8) & 0xff
+      arr[at + 2] = a & 0xff
+      at += 3
+    }
+  } else {
+    for (; i < mainLength; i += 4) {
+      const c0 = str.charCodeAt(i)
+      const c1 = str.charCodeAt(i + 1)
+      const c2 = str.charCodeAt(i + 2)
+      const c3 = str.charCodeAt(i + 3)
+      const a = (m[c0] << 18) | (m[c1] << 12) | (m[c2] << 6) | m[c3]
+      if (a < 0) throw new SyntaxError(E_CHAR)
+      arr[at] = a >> 16
+      arr[at + 1] = (a >> 8) & 0xff
+      arr[at + 2] = a & 0xff
+      at += 3
+    }
+  }
+
+  // Can be 0, 2 or 3, verified by padding checks already
+  if (tailLength < 2) return arr // 0
+  const ab = (m[str.charCodeAt(i++)] << 6) | m[str.charCodeAt(i++)]
+  if (ab < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ab >> 4
+  if (tailLength < 3) {
+    if (ab & 0xf) throw new SyntaxError(E_LAST)
+    return arr // 2
+  }
+
+  const c = m[str.charCodeAt(i++)]
+  if (c < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ((ab << 4) & 0xff) | (c >> 2)
+  if (c & 0x3) throw new SyntaxError(E_LAST)
+  return arr // 3
+}