@swiftbrowser/wasm-sdk-foundation 0.0.0-stage → 0.9.1

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStringDefaultEncoding.h

@@ -0,0 +1,45 @@
+/*	CFStringDefaultEncoding.h
+	Copyright (c) 1998-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFSTRINGDEFAULTENCODING__)
+#define __COREFOUNDATION_CFSTRINGDEFAULTENCODING__ 1
+
+#include "CFBase.h"
+
+#if TARGET_OS_OSX || TARGET_OS_IPHONE
+#include <stdlib.h>
+#include <fcntl.h>
+#include <pwd.h>
+#include <sys/param.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <xlocale.h>
+
+CF_EXTERN_C_BEGIN
+
+#define __kCFUserEncodingEnvVariableName ("__CF_USER_TEXT_ENCODING")
+#define __kCFMaxDefaultEncodingFileLength (64)
+#define __kCFUserEncodingFileName ("/.CFUserTextEncoding")
+
+CF_EXPORT void _CFStringGetUserDefaultEncoding(UInt32 *oScriptValue, UInt32 *oRegionValue);
+CF_EXPORT void _CFStringGetInstallationEncodingAndRegion(uint32_t *encoding, uint32_t *region);
+CF_EXPORT Boolean _CFStringSaveUserDefaultEncoding(UInt32 iScriptValue, UInt32 iRegionValue);
+
+CF_INLINE void __CFStringGetUserDefaultEncoding(UInt32 *oScriptValue, UInt32 *oRegionValue) { _CFStringGetUserDefaultEncoding(oScriptValue, oRegionValue); }
+CF_INLINE void __CFStringGetInstallationEncodingAndRegion(uint32_t *encoding, uint32_t *region) { _CFStringGetInstallationEncodingAndRegion(encoding, region); }
+CF_INLINE void __CFStringSaveUserDefaultEncoding(UInt32 iScriptValue, UInt32 iRegionValue) { _CFStringSaveUserDefaultEncoding(iScriptValue, iRegionValue); }
+
+CF_EXTERN_C_END
+
+#endif
+
+#endif /* ! __COREFOUNDATION_CFSTRINGDEFAULTENCODING__ */
+
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStringEncodingConverter.h

@@ -0,0 +1,82 @@
+/*	CFStringEncodingConverter.h
+	Copyright (c) 1998-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFSTRINGENCODINGCONVERTER__)
+#define __COREFOUNDATION_CFSTRINGENCODINGCONVERTER__ 1
+
+#include "CFString.h"
+
+
+CF_EXTERN_C_BEGIN
+
+/* Values for flags argument for the conversion functions below.  These can be combined, but the three NonSpacing behavior flags are exclusive.
+*/
+// kCFStringEncodingBasicDirectionLeftToRight ~ kCFStringEncodingPrependBOM will probably be deprecated and superseded by kCFStringEncodingPartialInput flag
+enum {
+    kCFStringEncodingAllowLossyConversion = (1UL << 0), // Uses fallback functions to substitutes non mappable chars
+    kCFStringEncodingBasicDirectionLeftToRight = (1UL << 1), // Converted with original direction left-to-right.
+    kCFStringEncodingBasicDirectionRightToLeft = (1UL << 2), // Converted with original direction right-to-left.
+    kCFStringEncodingSubstituteCombinings = (1UL << 3), // Uses fallback function to combining chars.
+    kCFStringEncodingComposeCombinings = (1UL << 4), // Checks mappable precomposed equivalents for decomposed sequences.  This is the default behavior.
+    kCFStringEncodingIgnoreCombinings = (1UL << 5), // Ignores combining chars.
+    kCFStringEncodingUseCanonical = (1UL << 6), // Always use canonical form
+    kCFStringEncodingUseHFSPlusCanonical = (1UL << 7), // Always use canonical form but leaves 0x2000 ranges
+    kCFStringEncodingPrependBOM = (1UL << 8), // Prepend BOM sequence (i.e. ISO2022KR)
+    kCFStringEncodingDisableCorporateArea = (1UL << 9), // Disable the usage of 0xF8xx area for Apple proprietary chars in converting to UniChar, resulting loosely mapping.
+    kCFStringEncodingASCIICompatibleConversion = (1UL << 10), // This flag forces strict ASCII compatible conversion. i.e. MacJapanese 0x5C maps to Unicode 0x5C.
+    kCFStringEncodingLenientUTF8Conversion = (1UL << 11), // 10.1 (Puma) compatible lenient UTF-8 conversion.
+    kCFStringEncodingPartialInput = (1UL << 12), // input buffer is a part of stream
+    kCFStringEncodingPartialOutput = (1UL << 13) // output buffer streaming
+};
+
+/* Return values for CFStringEncodingUnicodeToBytes & CFStringEncodingBytesToUnicode functions
+*/
+enum {
+    kCFStringEncodingConversionSuccess = 0,
+    kCFStringEncodingInvalidInputStream = 1,
+    kCFStringEncodingInsufficientOutputBufferLength = 2,
+    kCFStringEncodingConverterUnavailable = 3
+};
+
+/* Macro to shift lossByte argument.
+*/
+#define CFStringEncodingLossyByteToMask(lossByte)	((uint32_t)(lossByte << 24)|kCFStringEncodingAllowLossyConversion)
+#define CFStringEncodingMaskToLossyByte(flags)		((uint8_t)(flags >> 24))
+
+/* Macros for streaming support
+ */
+#define CFStringEncodingStreamIDMask                    (0x00FF0000)
+#define CFStringEncodingStreamIDFromMask(mask)    ((mask >> 16) & 0xFF)
+#define CFStringEncodingStreamIDToMask(identifier)            ((uint32_t)((identifier & 0xFF) << 16))
+
+/* Converts characters into the specified encoding.  Returns the constants defined above.
+If maxByteLen is 0, bytes is ignored. You can pass lossyByte by passing the value in flags argument.
+i.e. CFStringEncodingUnicodeToBytes(encoding, CFStringEncodingLossyByteToMask(lossByte), ....)
+*/
+CF_EXPORT uint32_t CFStringEncodingUnicodeToBytes(uint32_t encoding, uint32_t flags, const UniChar *characters, CFIndex numChars, CFIndex *usedCharLen, uint8_t *bytes, CFIndex maxByteLen, CFIndex *usedByteLen);
+
+/* Converts bytes in the specified encoding into unicode.  Returns the constants defined above.
+maxCharLen & usdCharLen are in UniChar length, not byte length.
+If maxCharLen is 0, characters is ignored.
+*/
+CF_EXPORT uint32_t CFStringEncodingBytesToUnicode(uint32_t encoding, uint32_t flags, const uint8_t *bytes, CFIndex numBytes, CFIndex *usedByteLen, UniChar *characters, CFIndex maxCharLen, CFIndex *usedCharLen);
+
+/* Fallback functions used when allowLossy
+*/
+typedef CFIndex (*CFStringEncodingToBytesFallbackProc)(const UniChar *characters, CFIndex numChars, uint8_t *bytes, CFIndex maxByteLen, CFIndex *usedByteLen);
+typedef CFIndex (*CFStringEncodingToUnicodeFallbackProc)(const uint8_t *bytes, CFIndex numBytes, UniChar *characters, CFIndex maxCharLen, CFIndex *usedCharLen);
+
+/* Can register functions used for lossy conversion.  Reregisters default procs if NULL
+*/
+CF_EXPORT void CFStringEncodingRegisterFallbackProcedures(uint32_t encoding, CFStringEncodingToBytesFallbackProc toBytes, CFStringEncodingToUnicodeFallbackProc toUnicode);
+
+CF_EXTERN_C_END
+
+#endif /* ! __COREFOUNDATION_CFSTRINGENCODINGCONVERTER__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStringEncodingConverterExt.h

@@ -0,0 +1,121 @@
+/*	CFStringEncodingConverterExt.h
+	Copyright (c) 1998-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFSTRINGENCODINGCONVERETEREXT__)
+#define __COREFOUNDATION_CFSTRINGENCODINGCONVERETEREXT__ 1
+
+#include "CFStringEncodingConverter.h"
+
+CF_EXTERN_C_BEGIN
+
+#define MAX_DECOMPOSED_LENGTH (10)
+
+enum {
+    kCFStringEncodingConverterStandard = 0,
+    kCFStringEncodingConverterCheapEightBit = 1,
+    kCFStringEncodingConverterStandardEightBit = 2,
+    kCFStringEncodingConverterCheapMultiByte = 3,
+    kCFStringEncodingConverterPlatformSpecific = 4, // Other fields are ignored
+    kCFStringEncodingConverterICU = 5 // Other fields are ignored
+};
+
+/* kCFStringEncodingConverterStandard */
+typedef CFIndex (*CFStringEncodingToBytesProc)(uint32_t flags, const UniChar *characters, CFIndex numChars, uint8_t *bytes, CFIndex maxByteLen, CFIndex *usedByteLen);
+typedef CFIndex (*CFStringEncodingToUnicodeProc)(uint32_t flags, const uint8_t *bytes, CFIndex numBytes, UniChar *characters, CFIndex maxCharLen, CFIndex *usedCharLen);
+/* kCFStringEncodingConverterCheapEightBit */
+typedef bool (*CFStringEncodingCheapEightBitToBytesProc)(uint32_t flags, UniChar character, uint8_t *byte);
+typedef bool (*CFStringEncodingCheapEightBitToUnicodeProc)(uint32_t flags, uint8_t byte, UniChar *character);
+/* kCFStringEncodingConverterStandardEightBit */
+typedef uint16_t (*CFStringEncodingStandardEightBitToBytesProc)(uint32_t flags, const UniChar *characters, CFIndex numChars, uint8_t *byte);
+typedef uint16_t (*CFStringEncodingStandardEightBitToUnicodeProc)(uint32_t flags, uint8_t byte, UniChar *characters);
+/* kCFStringEncodingConverterCheapMultiByte */
+typedef uint16_t (*CFStringEncodingCheapMultiByteToBytesProc)(uint32_t flags, UniChar character, uint8_t *bytes);
+typedef uint16_t (*CFStringEncodingCheapMultiByteToUnicodeProc)(uint32_t flags, const uint8_t *bytes, CFIndex numBytes, UniChar *character);
+
+typedef CFIndex (*CFStringEncodingToBytesLenProc)(uint32_t flags, const UniChar *characters, CFIndex numChars);
+typedef CFIndex (*CFStringEncodingToUnicodeLenProc)(uint32_t flags, const uint8_t *bytes, CFIndex numBytes);
+
+typedef CFIndex (*CFStringEncodingToBytesPrecomposeProc)(uint32_t flags, const UniChar *character, CFIndex numChars, uint8_t *bytes, CFIndex maxByteLen, CFIndex *usedByteLen);
+typedef bool (*CFStringEncodingIsValidCombiningCharacterProc)(UniChar character);
+
+typedef struct {
+    // These conversion functions should be accessed and called as dictated by .encodingClass.
+    // An encoding class of kCFStringEncodingConverterStandard corresponds to .standard; kCFStringEncodingConverterCheapEightBit corresponds to .cheapEightBit; etc.
+    union {
+        CFStringEncodingToBytesProc standard;
+        CFStringEncodingCheapEightBitToBytesProc cheapEightBit;
+        CFStringEncodingStandardEightBitToBytesProc standardEightBit;
+        CFStringEncodingCheapMultiByteToBytesProc cheapMultibyte;
+    } toBytes;
+    union {
+        CFStringEncodingToUnicodeProc standard;
+        CFStringEncodingCheapEightBitToUnicodeProc cheapEightBit;
+        CFStringEncodingStandardEightBitToUnicodeProc standardEightBit;
+        CFStringEncodingCheapMultiByteToUnicodeProc cheapMultibyte;
+    } toUnicode;
+
+    uint16_t maxBytesPerChar;
+    uint16_t maxDecomposedCharLen;
+    uint8_t encodingClass;
+    uint32_t :24;
+    CFStringEncodingToBytesLenProc toBytesLen;
+    CFStringEncodingToUnicodeLenProc toUnicodeLen;
+    CFStringEncodingToBytesFallbackProc toBytesFallback;
+    CFStringEncodingToUnicodeFallbackProc toUnicodeFallback;
+    CFStringEncodingToBytesPrecomposeProc toBytesPrecompose;
+    CFStringEncodingIsValidCombiningCharacterProc isValidCombiningChar;
+} CFStringEncodingConverter;
+
+enum {
+    kCFStringEncodingGetConverterSelector = 0,
+    kCFStringEncodingIsDecomposableCharacterSelector = 1,
+    kCFStringEncodingDecomposeCharacterSelector = 2,
+    kCFStringEncodingIsValidLatin1CombiningCharacterSelector = 3,
+    kCFStringEncodingPrecomposeLatin1CharacterSelector = 4
+};
+
+#define BOOTSTRAPFUNC_NAME	CFStringEncodingBootstrap
+typedef const CFStringEncodingConverter* (*CFStringEncodingBootstrapProc)(uint32_t encoding, const void *getSelector);
+
+/* Latin precomposition */
+/* This function does not precompose recursively nor to U+01E0 and U+01E1.
+*/
+extern bool CFStringEncodingIsValidCombiningCharacterForLatin1(UniChar character);
+extern UniChar CFStringEncodingPrecomposeLatinCharacter(const UniChar *character, CFIndex numChars, CFIndex *usedChars);
+
+/* Convenience functions for converter development */
+typedef struct _CFStringEncodingUnicodeTo8BitCharMap {
+    UniChar _u;
+    uint8_t _c;
+    uint8_t :8;
+} CFStringEncodingUnicodeTo8BitCharMap;
+
+/* Binary searches CFStringEncodingUnicodeTo8BitCharMap */
+CF_INLINE bool CFStringEncodingUnicodeTo8BitEncoding(const CFStringEncodingUnicodeTo8BitCharMap *theTable, CFIndex numElem, UniChar character, uint8_t *ch) {
+    const CFStringEncodingUnicodeTo8BitCharMap *p, *q, *divider;
+
+    if ((character < theTable[0]._u) || (character > theTable[numElem-1]._u)) {
+        return 0;
+    }
+    p = theTable;
+    q = p + (numElem-1);
+    while (p <= q) {
+        divider = p + ((q - p) >> 1);	/* divide by 2 */
+        if (character < divider->_u) { q = divider - 1; }
+        else if (character > divider->_u) { p = divider + 1; }
+        else { *ch = divider->_c; return 1; }
+    }
+    return 0;
+}
+
+
+CF_EXTERN_C_END
+
+#endif /* ! __COREFOUNDATION_CFSTRINGENCODINGCONVERETEREXT__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStringEncodingConverterPriv.h

@@ -0,0 +1,47 @@
+/*	CFStringEncodingConverterPriv.h
+	Copyright (c) 1998-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFSTRINGENCODINGCONVERTERPRIV__)
+#define __COREFOUNDATION_CFSTRINGENCODINGCONVERTERPRIV__ 1
+
+#include "CFBase.h"
+#include "CFStringEncodingConverterExt.h"
+
+CF_PRIVATE  const CFStringEncodingConverter __CFConverterASCII;
+CF_PRIVATE  const CFStringEncodingConverter __CFConverterISOLatin1;
+CF_PRIVATE  const CFStringEncodingConverter __CFConverterWinLatin1;
+CF_PRIVATE  const CFStringEncodingConverter __CFConverterNextStepLatin;
+CF_PRIVATE  const CFStringEncodingConverter __CFConverterUTF8;
+
+#if TARGET_OS_MAC
+CF_PRIVATE  const CFStringEncodingConverter __CFConverterMacRoman;
+#endif
+
+CF_PRIVATE  CFStringEncoding *__CFStringEncodingCreateListOfAvailablePlatformConverters(CFAllocatorRef allocator, CFIndex *numberOfConverters);
+CF_PRIVATE  const CFStringEncodingConverter *__CFStringEncodingGetExternalConverter(uint32_t encoding);
+CF_PRIVATE  CFIndex __CFStringEncodingPlatformUnicodeToBytes(uint32_t encoding, uint32_t flags, const UniChar *characters, CFIndex numChars, CFIndex *usedCharLen, uint8_t *bytes, CFIndex maxByteLen, CFIndex *usedByteLen);
+CF_PRIVATE  CFIndex __CFStringEncodingPlatformBytesToUnicode(uint32_t encoding, uint32_t flags, const uint8_t *bytes, CFIndex numBytes, CFIndex *usedByteLen, UniChar *characters, CFIndex maxCharLen, CFIndex *usedCharLen);
+CF_PRIVATE  CFIndex __CFStringEncodingPlatformCharLengthForBytes(uint32_t encoding, uint32_t flags, const uint8_t *bytes, CFIndex numBytes);
+CF_PRIVATE  CFIndex __CFStringEncodingPlatformByteLengthForCharacters(uint32_t encoding, uint32_t flags, const UniChar *characters, CFIndex numChars);
+
+/* Returns required length of destination buffer for conversion.  These functions are faster than specifying 0 to maxByteLen (maxCharLen), but unnecessarily optimal length
+ */
+CF_PRIVATE CFIndex CFStringEncodingCharLengthForBytes(uint32_t encoding, uint32_t flags, const uint8_t *bytes, CFIndex numBytes);
+CF_PRIVATE CFIndex CFStringEncodingByteLengthForCharacters(uint32_t encoding, uint32_t flags, const UniChar *characters, CFIndex numChars);
+
+CF_PRIVATE bool CFStringEncodingIsValidEncoding(uint32_t encoding);
+
+/* Returns kCFStringEncodingInvalidId terminated encoding list
+ */
+CF_PRIVATE const CFStringEncoding *CFStringEncodingListOfAvailableEncodings(void);
+
+CF_PRIVATE const CFStringEncodingConverter *CFStringEncodingGetConverter(uint32_t encoding);
+
+#endif /* ! __COREFOUNDATION_CFSTRINGENCODINGCONVERTERPRIV__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStringEncodingDatabase.h

@@ -0,0 +1,23 @@
+/*
+	CFStringEncodingDatabase.h
+	CoreFoundation
+ 
+	Copyright (c) 2007-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+ */
+
+#include "CFString.h"
+
+CF_PRIVATE uint16_t __CFStringEncodingGetWindowsCodePage(CFStringEncoding encoding);
+CF_PRIVATE CFStringEncoding __CFStringEncodingGetFromWindowsCodePage(uint16_t codepage);
+
+CF_PRIVATE bool __CFStringEncodingGetCanonicalName(CFStringEncoding encoding, char *buffer, CFIndex bufferSize);
+CF_PRIVATE CFStringEncoding __CFStringEncodingGetFromCanonicalName(const char *canonicalName);
+
+CF_PRIVATE CFStringEncoding __CFStringEncodingGetMostCompatibleMacScript(CFStringEncoding encoding);
+
+CF_PRIVATE const char *__CFStringEncodingGetName(CFStringEncoding encoding); // Returns simple non-localized name

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFStringEncodingExt.h

@@ -0,0 +1,184 @@
+/*	CFStringEncodingExt.h
+	Copyright (c) 1998-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFSTRINGENCODINGEXT__)
+#define __COREFOUNDATION_CFSTRINGENCODINGEXT__ 1
+
+#include "CFBase.h"
+
+CF_EXTERN_C_BEGIN
+
+typedef CF_ENUM(CFIndex, CFStringEncodings) {
+/*  kCFStringEncodingMacRoman = 0L, defined in CoreFoundation/CFString.h */
+    kCFStringEncodingMacJapanese = 1,
+    kCFStringEncodingMacChineseTrad = 2,
+    kCFStringEncodingMacKorean = 3,
+    kCFStringEncodingMacArabic = 4,
+    kCFStringEncodingMacHebrew = 5,
+    kCFStringEncodingMacGreek = 6,
+    kCFStringEncodingMacCyrillic = 7,
+    kCFStringEncodingMacDevanagari = 9,
+    kCFStringEncodingMacGurmukhi = 10,
+    kCFStringEncodingMacGujarati = 11,
+    kCFStringEncodingMacOriya = 12,
+    kCFStringEncodingMacBengali = 13,
+    kCFStringEncodingMacTamil = 14,
+    kCFStringEncodingMacTelugu = 15,
+    kCFStringEncodingMacKannada = 16,
+    kCFStringEncodingMacMalayalam = 17,
+    kCFStringEncodingMacSinhalese = 18,
+    kCFStringEncodingMacBurmese = 19,
+    kCFStringEncodingMacKhmer = 20,
+    kCFStringEncodingMacThai = 21,
+    kCFStringEncodingMacLaotian = 22,
+    kCFStringEncodingMacGeorgian = 23,
+    kCFStringEncodingMacArmenian = 24,
+    kCFStringEncodingMacChineseSimp = 25,
+    kCFStringEncodingMacTibetan = 26,
+    kCFStringEncodingMacMongolian = 27,
+    kCFStringEncodingMacEthiopic = 28,
+    kCFStringEncodingMacCentralEurRoman = 29,
+    kCFStringEncodingMacVietnamese = 30,
+    kCFStringEncodingMacExtArabic = 31,
+    /* The following use script code 0, smRoman */
+    kCFStringEncodingMacSymbol = 33,
+    kCFStringEncodingMacDingbats = 34,
+    kCFStringEncodingMacTurkish = 35,
+    kCFStringEncodingMacCroatian = 36,
+    kCFStringEncodingMacIcelandic = 37,
+    kCFStringEncodingMacRomanian = 38,
+    kCFStringEncodingMacCeltic = 39,
+    kCFStringEncodingMacGaelic = 40,
+    /* The following use script code 4, smArabic */
+    kCFStringEncodingMacFarsi = 0x8C,	/* Like MacArabic but uses Farsi digits */
+    /* The following use script code 7, smCyrillic */
+    kCFStringEncodingMacUkrainian = 0x98,
+    /* The following use script code 32, smUnimplemented */
+    kCFStringEncodingMacInuit = 0xEC,
+    kCFStringEncodingMacVT100 = 0xFC,	/* VT100/102 font from Comm Toolbox: Latin-1 repertoire + box drawing etc */
+    /* Special Mac OS encodings*/
+    kCFStringEncodingMacHFS = 0xFF,	/* Meta-value, should never appear in a table */
+
+    /* Unicode & ISO UCS encodings begin at 0x100 */
+    /* We don't use Unicode variations defined in TextEncoding; use the ones in CFString.h, instead. */
+
+    /* ISO 8-bit and 7-bit encodings begin at 0x200 */
+/*  kCFStringEncodingISOLatin1 = 0x0201, defined in CoreFoundation/CFString.h */
+    kCFStringEncodingISOLatin2 = 0x0202,	/* ISO 8859-2 */
+    kCFStringEncodingISOLatin3 = 0x0203,	/* ISO 8859-3 */
+    kCFStringEncodingISOLatin4 = 0x0204,	/* ISO 8859-4 */
+    kCFStringEncodingISOLatinCyrillic = 0x0205,	/* ISO 8859-5 */
+    kCFStringEncodingISOLatinArabic = 0x0206,	/* ISO 8859-6, =ASMO 708, =DOS CP 708 */
+    kCFStringEncodingISOLatinGreek = 0x0207,	/* ISO 8859-7 */
+    kCFStringEncodingISOLatinHebrew = 0x0208,	/* ISO 8859-8 */
+    kCFStringEncodingISOLatin5 = 0x0209,	/* ISO 8859-9 */
+    kCFStringEncodingISOLatin6 = 0x020A,	/* ISO 8859-10 */
+    kCFStringEncodingISOLatinThai = 0x020B,	/* ISO 8859-11 */
+    kCFStringEncodingISOLatin7 = 0x020D,	/* ISO 8859-13 */
+    kCFStringEncodingISOLatin8 = 0x020E,	/* ISO 8859-14 */
+    kCFStringEncodingISOLatin9 = 0x020F,	/* ISO 8859-15 */
+    kCFStringEncodingISOLatin10 = 0x0210,	/* ISO 8859-16 */
+
+    /* MS-DOS & Windows encodings begin at 0x400 */
+    kCFStringEncodingDOSLatinUS = 0x0400,	/* code page 437 */
+    kCFStringEncodingDOSGreek = 0x0405,		/* code page 737 (formerly code page 437G) */
+    kCFStringEncodingDOSBalticRim = 0x0406,	/* code page 775 */
+    kCFStringEncodingDOSLatin1 = 0x0410,	/* code page 850, "Multilingual" */
+    kCFStringEncodingDOSGreek1 = 0x0411,	/* code page 851 */
+    kCFStringEncodingDOSLatin2 = 0x0412,	/* code page 852, Slavic */
+    kCFStringEncodingDOSCyrillic = 0x0413,	/* code page 855, IBM Cyrillic */
+    kCFStringEncodingDOSTurkish = 0x0414,	/* code page 857, IBM Turkish */
+    kCFStringEncodingDOSPortuguese = 0x0415,	/* code page 860 */
+    kCFStringEncodingDOSIcelandic = 0x0416,	/* code page 861 */
+    kCFStringEncodingDOSHebrew = 0x0417,	/* code page 862 */
+    kCFStringEncodingDOSCanadianFrench = 0x0418, /* code page 863 */
+    kCFStringEncodingDOSArabic = 0x0419,	/* code page 864 */
+    kCFStringEncodingDOSNordic = 0x041A,	/* code page 865 */
+    kCFStringEncodingDOSRussian = 0x041B,	/* code page 866 */
+    kCFStringEncodingDOSGreek2 = 0x041C,	/* code page 869, IBM Modern Greek */
+    kCFStringEncodingDOSThai = 0x041D,		/* code page 874, also for Windows */
+    kCFStringEncodingDOSJapanese = 0x0420,	/* code page 932, also for Windows */
+    kCFStringEncodingDOSChineseSimplif = 0x0421, /* code page 936, also for Windows */
+    kCFStringEncodingDOSKorean = 0x0422,	/* code page 949, also for Windows; Unified Hangul Code */
+    kCFStringEncodingDOSChineseTrad = 0x0423,	/* code page 950, also for Windows */
+/*  kCFStringEncodingWindowsLatin1 = 0x0500, defined in CoreFoundation/CFString.h */
+    kCFStringEncodingWindowsLatin2 = 0x0501,	/* code page 1250, Central Europe */
+    kCFStringEncodingWindowsCyrillic = 0x0502,	/* code page 1251, Slavic Cyrillic */
+    kCFStringEncodingWindowsGreek = 0x0503,	/* code page 1253 */
+    kCFStringEncodingWindowsLatin5 = 0x0504,	/* code page 1254, Turkish */
+    kCFStringEncodingWindowsHebrew = 0x0505,	/* code page 1255 */
+    kCFStringEncodingWindowsArabic = 0x0506,	/* code page 1256 */
+    kCFStringEncodingWindowsBalticRim = 0x0507,	/* code page 1257 */
+    kCFStringEncodingWindowsVietnamese = 0x0508, /* code page 1258 */
+    kCFStringEncodingWindowsKoreanJohab = 0x0510, /* code page 1361, for Windows NT */
+
+    /* Various national standards begin at 0x600 */
+/*  kCFStringEncodingASCII = 0x0600, defined in CoreFoundation/CFString.h */
+    kCFStringEncodingANSEL = 0x0601,	/* ANSEL (ANSI Z39.47) */
+    kCFStringEncodingJIS_X0201_76 = 0x0620,
+    kCFStringEncodingJIS_X0208_83 = 0x0621,
+    kCFStringEncodingJIS_X0208_90 = 0x0622,
+    kCFStringEncodingJIS_X0212_90 = 0x0623,
+    kCFStringEncodingJIS_C6226_78 = 0x0624,
+    kCFStringEncodingShiftJIS_X0213 API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0)) = 0x0628, /* Shift-JIS format encoding of JIS X0213 planes 1 and 2*/
+    kCFStringEncodingShiftJIS_X0213_MenKuTen = 0x0629,	/* JIS X0213 in plane-row-column notation */
+    kCFStringEncodingGB_2312_80 = 0x0630,
+    kCFStringEncodingGBK_95 = 0x0631,		/* annex to GB 13000-93; for Windows 95 */
+    kCFStringEncodingGB_18030_2000 = 0x0632,
+    kCFStringEncodingKSC_5601_87 = 0x0640,	/* same as KSC 5601-92 without Johab annex */
+    kCFStringEncodingKSC_5601_92_Johab = 0x0641, /* KSC 5601-92 Johab annex */
+    kCFStringEncodingCNS_11643_92_P1 = 0x0651,	/* CNS 11643-1992 plane 1 */
+    kCFStringEncodingCNS_11643_92_P2 = 0x0652,	/* CNS 11643-1992 plane 2 */
+    kCFStringEncodingCNS_11643_92_P3 = 0x0653,	/* CNS 11643-1992 plane 3 (was plane 14 in 1986 version) */
+
+    /* ISO 2022 collections begin at 0x800 */
+    kCFStringEncodingISO_2022_JP = 0x0820,
+    kCFStringEncodingISO_2022_JP_2 = 0x0821,
+    kCFStringEncodingISO_2022_JP_1 = 0x0822, /* RFC 2237*/
+    kCFStringEncodingISO_2022_JP_3 = 0x0823, /* JIS X0213*/
+    kCFStringEncodingISO_2022_CN = 0x0830,
+    kCFStringEncodingISO_2022_CN_EXT = 0x0831,
+    kCFStringEncodingISO_2022_KR = 0x0840,
+
+    /* EUC collections begin at 0x900 */
+    kCFStringEncodingEUC_JP = 0x0920,		/* ISO 646, 1-byte katakana, JIS 208, JIS 212 */
+    kCFStringEncodingEUC_CN = 0x0930,		/* ISO 646, GB 2312-80 */
+    kCFStringEncodingEUC_TW = 0x0931,		/* ISO 646, CNS 11643-1992 Planes 1-16 */
+    kCFStringEncodingEUC_KR = 0x0940,		/* ISO 646, KS C 5601-1987 */
+
+    /* Misc standards begin at 0xA00 */
+    kCFStringEncodingShiftJIS = 0x0A01,		/* plain Shift-JIS */
+    kCFStringEncodingKOI8_R = 0x0A02,		/* Russian internet standard */
+    kCFStringEncodingBig5 = 0x0A03,		/* Big-5 (has variants) */
+    kCFStringEncodingMacRomanLatin1 = 0x0A04,	/* Mac OS Roman permuted to align with ISO Latin-1 */
+    kCFStringEncodingHZ_GB_2312 = 0x0A05,	/* HZ (RFC 1842, for Chinese mail & news) */
+    kCFStringEncodingBig5_HKSCS_1999 = 0x0A06, /* Big-5 with Hong Kong special char set supplement*/
+    kCFStringEncodingVISCII = 0x0A07,	/* RFC 1456, Vietnamese */
+    kCFStringEncodingKOI8_U = 0x0A08,	/* RFC 2319, Ukrainian */
+    kCFStringEncodingBig5_E = 0x0A09,	/* Taiwan Big-5E standard */
+
+    /* Other platform encodings*/
+/*  kCFStringEncodingNextStepLatin = 0x0B01, defined in CoreFoundation/CFString.h */
+    kCFStringEncodingNextStepJapanese = 0x0B02,	/* NextStep Japanese encoding */
+
+    /* EBCDIC & IBM host encodings begin at 0xC00 */
+    kCFStringEncodingEBCDIC_US = 0x0C01,	/* basic EBCDIC-US */
+    kCFStringEncodingEBCDIC_CP037 = 0x0C02,	/* code page 037, extended EBCDIC (Latin-1 set) for US,Canada... */
+
+    kCFStringEncodingUTF7 API_AVAILABLE(macos(10.6), ios(4.0), watchos(2.0), tvos(9.0)) = 0x04000100, /* kTextEncodingUnicodeDefault + kUnicodeUTF7Format RFC2152 */
+    kCFStringEncodingUTF7_IMAP API_AVAILABLE(macos(10.6), ios(4.0), watchos(2.0), tvos(9.0)) = 0x0A10, /* UTF-7 (IMAP folder variant) RFC3501 */
+
+    /* Deprecated constants */
+    kCFStringEncodingShiftJIS_X0213_00 = 0x0628 /* Shift-JIS format encoding of JIS X0213 planes 1 and 2 (DEPRECATED) */
+};
+
+CF_EXTERN_C_END
+
+#endif /* ! __COREFOUNDATION_CFSTRINGENCODINGEXT__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFString_Private.h

@@ -0,0 +1,32 @@
+/*    CFString_Private.h
+    Copyright (c) 2020, Apple Inc. All rights reserved.
+*/
+
+#if !defined(__COREFOUNDATION_CFSTRING_PRIVATE__)
+#define __COREFOUNDATION_CFSTRING_PRIVATE__ 1
+
+#include "CFString.h"
+#include "CFBundle.h"
+
+CF_ASSUME_NONNULL_BEGIN
+CF_EXTERN_C_BEGIN
+
+CF_EXPORT CFStringRef _Nullable _CFStringCreateTaggedPointerString(const uint8_t *bytes, CFIndex numBytes);
+
+// Returns a string containing the vocative case of \c givenName based on the language and region of \c locale.
+// Not all languages or regions use the vocative case, so very often, this will return \c givenName as-is.
+CF_EXPORT CFStringRef _Nullable _CFStringCopyVocativeCaseOfGivenName(CFStringRef givenName, CFLocaleRef locale) API_UNAVAILABLE(macos, ios, watchos, tvos);
+
+/*
+ If a process is loading strings manually from an Apple bundle, that process should use this call to ensure that any Markdown is parsed and inflected before using the string. If a process is using CFCopyLocalizedString…, CFBundleCopyLocalizedString, or the Foundation counterparts, this step is unnecessary, as those calls will do it for you if needed.
+ 
+ Note that only strings from Apple bundles need inflection; all others will just be returned retained.
+ */
+CF_EXPORT CFStringRef _CFStringCreateByParsingMarkdownAndInflectingIfNeeded(CFStringRef source, CFBundleRef _Nullable originBundle, CFURLRef _Nullable sourceStringsFileURLIfAny)
+    API_UNAVAILABLE(macos, ios, watchos, tvos);
+
+CF_EXTERN_C_END
+CF_ASSUME_NONNULL_END
+
+#endif /* ! __COREFOUNDATION_CFSTRING_PRIVATE__ */
+