Found 151735 results in 4410 files, showing top 50 files (show more).
github.com/googlecreativelab/pattern-radio:kubernetes/tools/classifier_clustering/package-lock.json: [ master, ]
1590:             "needle": "^2.2.1",
1573:         "needle": {
2:   "name": "classification_pooling",
github.com/PolymerLabs/arcs-live:concrete-storage/node_modules/grpc/node_modules/needle/README.md: [ master, ]
1: Needle
144: ### needle(method, url[, data][, options][, callback]) `(> 2.0.x)`
157: ### needle.head(url[, options][, callback])
170: ### needle.get(url[, options][, callback])
178: ### needle.post(url, data[, options][, callback])
190: ### needle.put(url, data[, options][, callback])
206: ### needle.patch(url, data[, options][, callback])
210: ### needle.delete(url, data[, options][, callback])
223: ### needle.request(method, url, data[, options][, callback])
4: [![NPM](https://nodei.co/npm/needle.png)](https://nodei.co/npm/needle/)
9: var needle = require('needle');
11: needle.get('http://www.google.com', function(error, response) {
17: Callbacks not floating your boat? Needle got your back.
25: // the callback is optional, and needle returns a `readableStream` object
27: needle
35: From version 2.0.x up, Promises are also supported. Just call `needle()` directly and you'll get a native Promise object.
38: needle('put', 'https://hacking.the.gibson/login', { password: 'god' }, { json: true })
47: With only two real dependencies, Needle supports:
61: This makes Needle an ideal alternative for performing quick HTTP requests in Node, either for API interaction, downlo...(144 bytes skipped)...
67: $ npm install needle
75: needle('get', 'https://server.com/posts/12')
84: needle.get('ifconfig.me/all.json', function(error, response, body) {
94: needle.get('https://google.com/images/logo.png').pipe(out).on('finish', function() {
99: As you can see, you can use Needle with Promises or without them. When using Promises or when a callback is passed, the response's bod...(179 bytes skipped)...
101: ...(19 bytes skipped)... passed, however, the buffering logic will be skipped but the response stream will still go through Needle's processing pipeline, so you get all the benefits of post-processing while keeping the streamishne...(25 bytes skipped)...
106: Depending on the response's Content-Type, Needle will either attempt to parse JSON or XML streams, or, if a text response was received, will ensure ...(41 bytes skipped)...
111: needle.get('http://stackoverflow.com/feeds', { compressed: true }, function(err, resp) {
126: var stream = needle.get('https://backend.server.com/everything.html', options);
146: Calling `needle()` directly returns a Promise. Besides `method` and `url`, all parameters are optional, although wh...(93 bytes skipped)...
149: needle('get', 'http://some.url.com')
155: Except from the above, all of Needle's request methods return a Readable stream, and both `options` and `callback` are optional. If pass...(126 bytes skipped)...
160: needle.head('https://my.backend.server.com', {
173: needle.get('google.com/search?q=syd+barrett', function(err, resp) {
174:   // if no http:// is found, Needle will automagically prepend it.
185: needle.post('https://my.app.com/endpoint', 'foo=bar', options, function(err, resp) {
201: needle.put('https://api.app.com/v2', nested, function(err, resp) {
218: needle.delete('https://api.app.com/messages/123', null, options, function(err, resp) {
233: needle.request('get', 'forum.com/search', params, function(err, resp) {
239: Now, if you set pass `json: true` among the options, Needle won't set your params as a querystring but instead send a JSON representation of your data through ...(97 bytes skipped)...
242: needle.request('get', 'forum.com/search', params, { json: true }, function(err, resp) {
250: The [Readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) object returned by the above request methods emits the following events, in additi...(73 bytes skipped)...
256: Emitted when the underlying [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest) emits a response event. This is after the connection is established and the hea...(146 bytes skipped)...
275: ...(74 bytes skipped)... data was consumed or an error ocurred somewhere in between. Unlike a regular stream's `end` event, Needle's `done` will be fired either on success or on failure, which is why the first argument may be an E...(28 bytes skipped)...
278: var resp = needle.get('something.worthy/of/being/streamed/by/needle');
291: Emitted when an error ocurrs. This should only happen once in the lifecycle of a Needle request.
302: ...(3 bytes skipped)... information about options that've changed, there's always [the changelog](https://github.com/tomas/needle/releases).
304:  - `agent`       : Uses an [http.Agent](https://nodejs.org/api/http.html#http_class_http_agent) of your choice, instead of the global, default one. Useful for tweaking the behaviour a...(80 bytes skipped)...
314: ...(182 bytes skipped)...p) errors on some servers that misbehave when receiving payloads of unknown size. Set it to `0` and Needle will get and set the stream's length for you, or leave unset for the default behaviour, which is no...(43 bytes skipped)...
321: ...(71 bytes skipped)...se bodies automagically. Defaults to `true`. You can also set this to 'xml' or 'json' in which case Needle will *only* parse the response if the content type matches.
336:  - `user_agent`: Sets the 'User-Agent' HTTP header. Defaults to `Needle/{version} (Node.js {node_version})`.
361:  - `follow_if_same_host`     : When true, Needle will only follow redirects that point to the same host as the original request. `false` by default....(0 bytes skipped)...
362:  - `follow_if_same_protocol` : When true, Needle will only follow redirects that point to the same protocol as the original request. `false` by defa...(4 bytes skipped)...
367: Yes sir, we have it. Needle includes a `defaults()` method, that lets you override some of the defaults for all future requests...(12 bytes skipped)...
370: needle.defaults({
376: This will override Needle's default user agent and 10-second timeout, and disable response parsing, so you don't need to pass...(38 bytes skipped)...
381: Since you can pass a custom HTTPAgent to Needle you can do all sorts of neat stuff. For example, if you want to use the [`tunnel`](https://github.c...(67 bytes skipped)...
389: needle.get('foobar.com', { agent: myAgent });
395: Unless you're running an old version of Node (< 0.11.4), by default Needle won't set the Connection header on requests, yielding Node's default behaviour of keeping the conne...(118 bytes skipped)...
397: ...(82 bytes skipped)...ime from exiting, either because of a bug or 'feature' that was changed on 0.11.4. To overcome this Needle does set the 'Connection' header to 'close' on those versions, however this also means that making ...(62 bytes skipped)...
407: needle.get('https://api.server.com', { username: 'you', password: 'secret' },
416: needle.get('https://username:password@api.server.com', function(err, resp) {
424: needle.get('other.server.com', { username: 'you', password: 'secret', auth: 'digest' },
426:     // needle prepends 'http://' to your URL, if missing
439: needle.get('api.github.com/users/tomas', options, function(err, resp, body) {
448: needle.get('https://news.ycombinator.com/rss', function(err, resp, body) {
456: needle.get('http://upload.server.com/tux.png', { output: '/tmp/tux.png' }, function(err, resp, body) {
464: needle.get('http://search.npmjs.org', { proxy: 'http://localhost:1234' }, function(err, resp, body) {
472: var stream = needle.get('http://www.as35662.net/100.log');
485: var stream = needle.get('http://jsonplaceholder.typicode.com/db', { parse: true });
504: needle.get('http://jsonplaceholder.typicode.com/db', { parse: true })
519: needle.post('http://my.other.app.com', data, { multipart: true }, function(err, resp, body) {
520:   // needle will read the file and include it in the form-data as binary
527: needle.put('https://api.app.com/v2', fs.createReadStream('myfile.txt'), function(err, resp, body) {
545: needle.post('http://somewhere.com/over/the/rainbow', data, { multipart: true }, function(err, resp, body) ...(1 bytes skipped)...
563: needle.post('http://test.com/', data, { timeout: 5000, multipart: true }, function(err, resp, body) {
582: > You can use Docker to run tests by creating a container and mounting the needle project directory on `/app`
583: > `docker create --name Needle -v /app -w /app -v /app/node_modules -i node:argon`
github.com/kubernetes/minikube:site/package-lock.json: [ master, ]
1127:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
643:         "posix-character-classes": "^0.1.0",
388:     "class-utils": {
390:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1108:         "needle": {
2138:     "posix-character-classes": {
2140:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/kubernetes/minikube:site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/apache/beam:website/www/site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/dart-lang/sdk:runtime/vm/object.h: [ master, ]
973: class Class : public Object {
471:   static ClassPtr class_class() { return class_class_; }
472:   static ClassPtr dynamic_class() { return dynamic_class_; }
473:   static ClassPtr void_class() { return void_class_; }
474:   static ClassPtr type_parameters_class() { return type_parameters_class_; }
475:   static ClassPtr type_arguments_class() { return type_arguments_class_; }
476:   static ClassPtr patch_class_class() { return patch_class_class_; }
477:   static ClassPtr function_class() { return function_class_; }
478:   static ClassPtr closure_data_class() { return closure_data_class_; }
479:   static ClassPtr ffi_trampoline_data_class() {
482:   static ClassPtr field_class() { return field_class_; }
483:   static ClassPtr script_class() { return script_class_; }
484:   static ClassPtr library_class() { return library_class_; }
485:   static ClassPtr namespace_class() { return namespace_class_; }
486:   static ClassPtr kernel_program_info_class() {
489:   static ClassPtr code_class() { return code_class_; }
490:   static ClassPtr instructions_class() { return instructions_class_; }
491:   static ClassPtr instructions_section_class() {
494:   static ClassPtr instructions_table_class() {
497:   static ClassPtr object_pool_class() { return object_pool_class_; }
498:   static ClassPtr pc_descriptors_class() { return pc_descriptors_class_; }
499:   static ClassPtr code_source_map_class() { return code_source_map_class_; }
500:   static ClassPtr compressed_stackmaps_class() {
503:   static ClassPtr var_descriptors_class() { return var_descriptors_class_; }
504:   static ClassPtr exception_handlers_class() {
507:   static ClassPtr deopt_info_class() { return deopt_info_class_; }
508:   static ClassPtr context_class() { return context_class_; }
509:   static ClassPtr context_scope_class() { return context_scope_class_; }
510:   static ClassPtr sentinel_class() { return sentinel_class_; }
511:   static ClassPtr api_error_class() { return api_error_class_; }
512:   static ClassPtr language_error_class() { return language_error_class_; }
513:   static ClassPtr unhandled_exception_class() {
516:   static ClassPtr unwind_error_class() { return unwind_error_class_; }
517:   static ClassPtr singletargetcache_class() { return singletargetcache_class_; }
518:   static ClassPtr unlinkedcall_class() { return unlinkedcall_class_; }
519:   static ClassPtr monomorphicsmiablecall_class() {
522:   static ClassPtr icdata_class() { return icdata_class_; }
523:   static ClassPtr megamorphic_cache_class() { return megamorphic_cache_class_; }
524:   static ClassPtr subtypetestcache_class() { return subtypetestcache_class_; }
525:   static ClassPtr loadingunit_class() { return loadingunit_class_; }
526:   static ClassPtr weak_serialization_reference_class() {
808:   static ClassPtr class_class_;            // Class of the Class vm object.
1447:   UntaggedClass::ClassLoadingState class_loading_state() const {
1462:   bool is_synthesized_class() const {
1468:   bool is_enum_class() const { return EnumBit::decode(state_bits()); }
1865:   ClassPtr patched_class() const { return untag()->patched_class(); }
1866:   ClassPtr origin_class() const { return untag()->origin_class(); }
4736:   ClassPtr toplevel_class() const { return untag()->toplevel_class(); }
8688:   virtual ClassPtr type_class() const {
1302:   bool IsNullClass() const { return id() == kNullCid; }
1305:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1308:   bool IsVoidClass() const { return id() == kVoidCid; }
1311:   bool IsNeverClass() const { return id() == kNeverCid; }
1314:   bool IsObjectClass() const { return id() == kInstanceCid; }
1323:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1326:   bool IsClosureClass() const { return id() == kClosureCid; }
1327:   static bool IsClosureClass(ClassPtr cls) {
1752:   class ClassFinalizedBits : public BitField<uint32_t,
1756:   class ClassLoadingBits : public BitField<uint32_t,
1859:   kCurrentClass,  // Consider type params of current class only.
1863: class PatchClass : public Object {
4585: class ClassDictionaryIterator : public DictionaryIterator {
5105:   ArrayPtr classes_cache() const { return untag()->classes_cache(); }
7295:   intptr_t SizeFromClass() const {
7933:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
8223:   virtual bool HasTypeClass() const {
8391:   virtual bool HasTypeClass() const { return false; }
8679:   virtual bool HasTypeClass() const {
8761:   virtual bool HasTypeClass() const { return false; }
315: #define DEFINE_CLASS_TESTER(clazz)                                             \
809:   static ClassPtr dynamic_class_;          // Class of the 'dynamic' type.
810:   static ClassPtr void_class_;             // Class of the 'void' type.
811:   static ClassPtr type_parameters_class_;  // Class of TypeParameters vm object.
812:   static ClassPtr type_arguments_class_;   // Class of TypeArguments vm object.
813:   static ClassPtr patch_class_class_;      // Class of the PatchClass vm object.
814:   static ClassPtr function_class_;         // Class of the Function vm object.
815:   static ClassPtr closure_data_class_;     // Class of ClosureData vm obj.
816:   static ClassPtr ffi_trampoline_data_class_;  // Class of FfiTrampolineData
818:   static ClassPtr field_class_;                // Class of the Field vm object.
819:   static ClassPtr script_class_;               // Class of the Script vm object.
820:   static ClassPtr library_class_;    // Class of the Library vm object.
821:   static ClassPtr namespace_class_;  // Class of Namespace vm object.
822:   static ClassPtr kernel_program_info_class_;  // Class of KernelProgramInfo vm
824:   static ClassPtr code_class_;                 // Class of the Code vm object.
826:   static ClassPtr instructions_class_;  // Class of the Instructions vm object.
827:   static ClassPtr instructions_section_class_;  // Class of InstructionsSection.
828:   static ClassPtr instructions_table_class_;    // Class of InstructionsTable.
829:   static ClassPtr object_pool_class_;      // Class of the ObjectPool vm object.
830:   static ClassPtr pc_descriptors_class_;   // Class of PcDescriptors vm object.
831:   static ClassPtr code_source_map_class_;  // Class of CodeSourceMap vm object.
832:   static ClassPtr compressed_stackmaps_class_;  // Class of CompressedStackMaps.
833:   static ClassPtr var_descriptors_class_;       // Class of LocalVarDescriptors.
834:   static ClassPtr exception_handlers_class_;    // Class of ExceptionHandlers.
835:   static ClassPtr deopt_info_class_;            // Class of DeoptInfo.
836:   static ClassPtr context_class_;            // Class of the Context vm object.
837:   static ClassPtr context_scope_class_;      // Class of ContextScope vm object.
838:   static ClassPtr sentinel_class_;           // Class of Sentinel vm object.
839:   static ClassPtr singletargetcache_class_;  // Class of SingleTargetCache.
840:   static ClassPtr unlinkedcall_class_;       // Class of UnlinkedCall.
842:       monomorphicsmiablecall_class_;         // Class of MonomorphicSmiableCall.
843:   static ClassPtr icdata_class_;             // Class of ICData.
844:   static ClassPtr megamorphic_cache_class_;  // Class of MegamorphiCache.
845:   static ClassPtr subtypetestcache_class_;   // Class of SubtypeTestCache.
846:   static ClassPtr loadingunit_class_;        // Class of LoadingUnit.
847:   static ClassPtr api_error_class_;          // Class of ApiError.
848:   static ClassPtr language_error_class_;     // Class of LanguageError.
849:   static ClassPtr unhandled_exception_class_;  // Class of UnhandledException.
850:   static ClassPtr unwind_error_class_;         // Class of UnwindError.
852:   static ClassPtr weak_serialization_reference_class_;
2512:   bool include_class_name = true;
4607:   Class& toplevel_class_;
8201:   static intptr_t type_class_id_offset() {
8396:   virtual classid_t type_class_id() const { return kIllegalCid; }
8685:   virtual classid_t type_class_id() const {
8762:   virtual classid_t type_class_id() const { return kIllegalCid; }
8773:   static intptr_t parameterized_class_id_offset() {
307:   intptr_t GetClassId() const {
564:   static const ClassId kClassId = kObjectCid;
1286:   GrowableObjectArrayPtr direct_subclasses() const {
1291:   GrowableObjectArrayPtr direct_subclasses_unsafe() const {
1337:   static intptr_t GetClassId(ClassPtr cls) {
1735:     kClassFinalizedPos = 2,
1736:     kClassFinalizedSize = 2,
1737:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1738:     kClassLoadingSize = 2,
1740:     kSynthesizedClassBit,
1761:   class SynthesizedClassBit
2262:   ICDataPtr AsUnaryClassChecks() const { return AsUnaryClassChecksForArgNr(0); }
2528:   static NameFormattingParams DisambiguatedWithoutClassName(
6442:   classid_t OwnerClassId() const { return OwnerClassIdOf(ptr()); }
6443:   static classid_t OwnerClassIdOf(CodePtr raw) {
6921:     kClassIdIndex,
8766:   bool IsClassTypeParameter() const {
9628:   static const ClassId kClassId = kOneByteStringCid;
9750:   static const ClassId kClassId = kTwoByteStringCid;
9827:   static const ClassId kClassId = kExternalOneByteStringCid;
9916:   static const ClassId kClassId = kExternalTwoByteStringCid;
10206:   static const ClassId kClassId = kImmutableArrayCid;
11949: ObjectPtr MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
46: class Assembler;
50: class Program;
51: class TreeNode;
54: #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
55: CLASS_LIST(DEFINE_FORWARD_DECLARATION)
57: class Api;
58: class ArgumentsDescriptor;
59: class Closure;
60: class Code;
61: class DeoptInstr;
62: class DisassemblyFormatter;
63: class FinalizablePersistentHandle;
64: class FlowGraphCompiler;
65: class HierarchyInfo;
66: class LocalScope;
67: class CallSiteResetter;
68: class CodeStatistics;
69: class IsolateGroupReloadContext;
71: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
75: class Symbols;
76: class BaseTextBuffer;
85: // ContainsCompressedPointers() returns the same value for AllStatic class and
86: // class used for handles.
219:   friend class object##MessageSerializationCluster;                            \
220:   friend class object##MessageDeserializationCluster;
236:   friend class Object;
245:   friend class StackFrame;                                                     \
246:   friend class Thread;
270:   friend class Object;                                                         \
271:   friend class StackFrame;                                                     \
272:   friend class Thread;
289: class Object {
314: // Class testers.
317:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
318: #undef DEFINE_CLASS_TESTER
423:   V(Class, null_class)                                                         \
480:     return ffi_trampoline_data_class_;
487:     return kernel_program_info_class_;
492:     return instructions_section_class_;
495:     return instructions_table_class_;
501:     return compressed_stackmaps_class_;
505:     return exception_handlers_class_;
514:     return unhandled_exception_class_;
520:     return monomorphicsmiablecall_class_;
527:     return weak_serialization_reference_class_;
554:   template <class FakeObject>
579:     //   core impl class name shown -> _OneByteString
608:   // class which has the same name as an already existing function, or
615:   enum class NameDisambiguation {
754:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
774:     // Indicates this class cannot be extended by dart code.
783:   static void RegisterClass(const Class& cls,
786:   static void RegisterPrivateClass(const Class& cls,
851:   // Class of WeakSerializationReference.
858:   friend void ClassTable::Register(const Class& cls);
860:   friend class Closure;
861:   friend class InstanceDeserializationCluster;
862:   friend class OneByteString;
863:   friend class TwoByteString;
864:   friend class ExternalOneByteString;
865:   friend class ExternalTwoByteString;
866:   friend class Thread;
869:   friend class Reusable##name##HandleScope;
889: class PassiveObject : public Object {
937: // The first string in the triplet is a type name (usually a class).
942: enum class Nullability : uint8_t {
950: enum class TypeEquality {
958: enum class NNBDMode {
966: enum class NNBDCompiledMode {
1091:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1092:   // to this class.
1095:   // The NNBD mode of the library declaring this class.
1131:   // Return the Type with type parameters declared by this class filled in with
1137:   // class preceded by the type arguments declared for superclasses, etc.
1139:   // class B<T, S>
1140:   // class C<R> extends B<R, int>
1171:   // the super class.
1174:   // Return true if this class declares type parameters.
1187:   // If this class is parameterized, each instance has a type_arguments field.
1202:         compiler::target::Class::kNoTypeArguments) {
1203:       return compiler::target::Class::kNoTypeArguments;
1215:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1217:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1219:       target_value = RTN::Class::kNoTypeArguments;
1244:   // The super type of this class, Object type if not explicitly specified.
1254:   // Asserts that the class of the super type has been resolved.
1268:   // Returns the list of classes directly implementing this class.
1281:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1285:   // Returns the list of classes having this class as direct superclass.
1298:   void AddDirectSubclass(const Class& subclass) const;
1301:   // Check if this class represents the class of null.
1304:   // Check if this class represents the 'dynamic' class.
1307:   // Check if this class represents the 'void' class.
1310:   // Check if this class represents the 'Never' class.
1313:   // Check if this class represents the 'Object' class.
1316:   // Check if this class represents the 'Function' class.
1319:   // Check if this class represents the 'Future' class.
1322:   // Check if this class represents the 'FutureOr' class.
1325:   // Check if this class represents the 'Closure' class.
1344:   static bool IsSubtypeOf(const Class& cls,
1351:   // Check if this is the top level class.
1359:   // Returns an array of instance and static fields defined by this class.
1369:   // If this is a dart:internal.ClassID class, then inject our own const
1374:   // Returns an array of all instance fields of this class and its superclasses
1397:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1452:     return class_loading_state() >= UntaggedClass::kDeclarationLoaded;
1458:     return class_loading_state() >= UntaggedClass::kTypeFinalized;
1465:   void set_is_synthesized_class() const;
1466:   void set_is_synthesized_class_unsafe() const;
1469:   void set_is_enum_class() const;
1496:   // Tests if this is a mixin application class which was desugared
1497:   // to a normal class by kernel mixin transformation
1554:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1579:   // class and return the resulting value, or an error object if evaluating the
1589:   // Load class declaration (super type, interfaces, type parameters and
1596:   // Allocate a class used for VM internal objects.
1597:   template <class FakeObject, class TargetFakeObject>
1598:   static ClassPtr New(IsolateGroup* isolate_group, bool register_class = true);
1605:                       bool register_class = true);
1611:   static ClassPtr NewStringClass(intptr_t class_id,
1615:   static ClassPtr NewTypedDataClass(intptr_t class_id,
1619:   static ClassPtr NewTypedDataViewClass(intptr_t class_id,
1623:   static ClassPtr NewExternalTypedDataClass(intptr_t class_id,
1627:   static ClassPtr NewPointerClass(intptr_t class_id,
1632:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1636:   void DisableCHAOptimizedCode(const Class& subclass);
1642:   // Return the list of code objects that were compiled using CHA of this class.
1643:   // These code objects will be invalidated if new subclasses of this class
1653:                    const Class& old_enum) const;
1655:                              const Class& old_cls) const;
1658:                                      const Class& new_cls) const;
1659:   void CopyCanonicalConstants(const Class& old_cls) const;
1660:   void CopyDeclarationType(const Class& old_cls) const;
1661:   void CheckReload(const Class& replacement,
1710:   // Caches the declaration type of this class.
1713:   bool CanReloadFinalized(const Class& replacement,
1715:   bool CanReloadPreFinalized(const Class& replacement,
1719:   bool RequiresInstanceMorphing(const Class& replacement) const;
1721:   template <class FakeInstance, class TargetFakeInstance>
1750:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1751:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1760:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1763:   class FieldsMarkedNullableBit
1765:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1766:   class TransformedMixinApplicationBit
1768:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1769:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1770:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1816:   // Calculates number of type arguments of this class.
1821:   // Assigns empty array to all raw class array fields.
1835:   // Allocate an instance class which has a VM implementation.
1836:   template <class FakeInstance, class TargetFakeInstance>
1839:                       bool register_class = true,
1842:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
1845:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
1846:   friend class AbstractType;
1847:   friend class Instance;
1848:   friend class Object;
1849:   friend class Type;
1850:   friend class Intrinsifier;
1851:   friend class ProgramWalker;
1852:   friend class Precompiler;
1853:   friend class ClassFinalizer;
1858:   kAny,           // Consider type params of current class and functions.
1890:     return Class::IsInFullSnapshot(cls->untag()->patched_class());
1893:   static PatchClassPtr New(const Class& patched_class,
1894:                            const Class& origin_class);
1896:   static PatchClassPtr New(const Class& patched_class, const Script& source);
1899:   void set_patched_class(const Class& value) const;
1900:   void set_origin_class(const Class& value) const;
1906:   friend class Class;
1909: class SingleTargetCache : public Object {
1939:   friend class Class;
1942: class MonomorphicSmiableCall : public Object {
1968:   friend class Class;
1971: class CallSiteData : public Object {
2000:   friend class ICData;
2001:   friend class MegamorphicCache;
2004: class UnlinkedCall : public CallSiteData {
2020:   friend class ICData;  // For set_*() methods.
2025:   friend class Class;
2033: class ICData : public CallSiteData {
2197:   // Ensures there is a check for [class_ids].
2202:   void EnsureHasCheck(const GrowableArray<intptr_t>& class_ids,
2206:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2208:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2214:   // Ensures there is a receiver check for [receiver_class_id].
2220:       intptr_t receiver_class_id,
2226:   // Adds sorted so that Smi is the first class-id. Use only for
2228:   void AddReceiverCheck(intptr_t receiver_class_id,
2237:                   GrowableArray<intptr_t>* class_ids,
2239:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2243:                           intptr_t* class_id,
2272:   bool HasReceiverClassId(intptr_t class_id) const;
2385:   void AddCheckInternal(const GrowableArray<intptr_t>& class_ids,
2388:   void AddReceiverCheckInternal(intptr_t receiver_class_id,
2427:   class NumArgsTestedBits : public BitField<uint32_t,
2431:   class TrackingExactnessBit : public BitField<uint32_t,
2435:   class DeoptReasonBits : public BitField<uint32_t,
2439:   class RebindRuleBits : public BitField<uint32_t,
2443:   class MegamorphicBit
2446:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2476:   friend class CallSiteResetter;
2477:   friend class CallTargets;
2478:   friend class Class;
2479:   friend class VMDeserializationRoots;
2480:   friend class ICDataTestTask;
2481:   friend class VMSerializationRoots;
2508:   // By default function name includes the name of the enclosing class if any.
2509:   // However in some contexts this information is redundant and class name
2510:   // is already known. In this case setting |include_class_name| to false
2531:     params.include_class_name = false;
2538:     params.include_class_name = false;
2544: class Function : public Object {
2609:   // parameter of this function and R is a type parameter of class C, the owner
2615:   // parameter of this function and R is a type parameter of class C, the owner
2624:   // generic functions or class type parameters.
2638:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3520:       const Class& klass = Class::Handle(Owner());
3615: // a hoisted check class instruction.
3630:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3659:   // static: Considered during class-side or top-level resolution rather than
3753:   class KindBits : public BitField<uint32_t,
3758:   class RecognizedBits : public BitField<uint32_t,
3762:   class ModifierBits : public BitField<uint32_t,
3768:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
3805:   friend class Class;
3806:   friend class Parser;  // For set_eval_script.
3809:   friend class UntaggedFunction;
3810:   friend class ClassFinalizer;  // To reset parent_function.
3811:   friend class Type;            // To adjust parent_function.
3812:   friend class Precompiler;     // To access closure data.
3813:   friend class ProgramVisitor;  // For set_parameter_types/names.
3816: class ClosureData : public Object {
3847:   friend class Class;
3848:   friend class Function;
3849:   friend class Precompiler;  // To wrap parent functions in WSRs.
3852: enum class EntryPointPragma {
3860: class FfiTrampolineData : public Object {
3887:   friend class Class;
3888:   friend class Function;
3891: class Field : public Object {
4013:   // Called during class finalization.
4037:   ClassPtr Origin() const;  // Either mixin class, or same as owner().
4042:   // Used by class finalizer, otherwise initialized in constructor.
4157:   // Return class id that any non-null value read from this field is guaranteed
4158:   // to have or kDynamicCid if such class id is not known.
4279:   // assumptions about guarded class id and nullability of this field.
4359:   friend class StoreInstanceFieldInstr;  // Generated code access to bit field.
4379:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4380:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4381:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4382:   class HasNontrivialInitializerBit
4384:   class UnboxingCandidateBit
4386:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4387:   class DoubleInitializedBit
4389:   class InitializerChangedAfterInitializatonBit
4394:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4395:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4396:   class GenericCovariantImplBit
4398:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4399:   class IsExtensionMemberBit
4401:   class NeedsLoadGuardBit
4403:   class HasInitializerBit
4405:   class IsNonNullableIntBit
4448:   friend class Class;
4449:   friend class UntaggedField;
4450:   friend class FieldSerializationCluster;
4451:   friend class FieldDeserializationCluster;
4454: class Script : public Object {
4561:   friend class Class;
4562:   friend class Precompiler;
4565: class DictionaryIterator : public ValueObject {
4581:   friend class ClassDictionaryIterator;
4589:     // one top-level class per library left, not an array to iterate over.
4598:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4601:   // Returns a non-null raw class.
4612: class Library : public Object {
4674:   void AddClass(const Class& cls) const;
4709:   void AddAnonymousClass(const Class& cls) const;
4737:   void set_toplevel_class(const Class& value) const;
4913:   // Lookup class in the core lib which also contains various VM
4915:   static ClassPtr LookupCoreClass(const String& class_name);
4919:                                  const char* class_name,
4990:   friend class Bootstrap;
4991:   friend class Class;
4992:   friend class Debugger;
4993:   friend class DictionaryIterator;
4994:   friend class Isolate;
4995:   friend class LibraryDeserializationCluster;
4996:   friend class Namespace;
4997:   friend class Object;
4998:   friend class Precompiler;
5003: class Namespace : public Object {
5027:   friend class Class;
5028:   friend class Precompiler;
5031: class KernelProgramInfo : public Object {
5110:                        const Class& klass) const;
5116:   friend class Class;
5122: class ObjectPool : public Object {
5256:   friend class Class;
5257:   friend class Object;
5258:   friend class UntaggedObjectPool;
5261: class Instructions : public Object {
5270:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5271:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5428:   friend class Class;
5429:   friend class Code;
5430:   friend class AssemblyImageWriter;
5431:   friend class BlobImageWriter;
5432:   friend class ImageWriter;
5445: class InstructionsSection : public Object {
5466:   // There are no public instance methods for the InstructionsSection class, as
5467:   // all access to the contents is handled by methods on the Image class.
5475:   friend class Class;
5481: class InstructionsTable : public Object {
5583:   friend class Class;
5586: class LocalVarDescriptors : public Object {
5623:   friend class Class;
5624:   friend class Object;
5627: class PcDescriptors : public Object {
5660:   class Iterator : ValueObject {
5716:     friend class PcDescriptors;
5761:   friend class Class;
5762:   friend class Object;
5765: class CodeSourceMap : public Object {
5804:   friend class Class;
5805:   friend class Object;
5808: class CompressedStackMaps : public Object {
5873:   class Iterator {
5945:     friend class StackMapEntry;
5955:   friend class Class;
5958: class ExceptionHandlers : public Object {
6014:   friend class Class;
6015:   friend class Object;
6039: class WeakSerializationReference : public Object {
6071:   friend class Class;
6074: class Code : public Object {
6291:   enum class PoolAttachment {
6296:   class KindField : public BitField<intptr_t, CallKind, 0, 3> {};
6297:   class EntryPointField
6299:   class OffsetField
6325:   class Comments : public ZoneAllocated, public CodeComments {
6348:     friend class Code;
6427:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
6577:   friend class UntaggedObject;  // For UntaggedObject::SizeFromClass().
6578:   friend class UntaggedCode;
6590:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
6594:   class ForceOptimizedBit
6597:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
6603:   class DiscardedBit : public BitField<int32_t, bool, kDiscardedBit, 1> {};
6605:   class PtrOffBits
6608:   class SlowFindRawCodeVisitor : public FindObjectVisitor {
6698:   friend class Class;
6699:   friend class CodeTestHelper;
6700:   friend class StubCode;     // for set_object_pool
6701:   friend class Precompiler;  // for set_object_pool
6702:   friend class FunctionSerializationCluster;
6703:   friend class CodeSerializationCluster;
6704:   friend class CodeDeserializationCluster;
6705:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
6706:   friend class StubCode;               // for set_object_pool
6707:   friend class MegamorphicCacheTable;  // for set_object_pool
6708:   friend class CodePatcher;            // for set_instructions
6709:   friend class ProgramVisitor;         // for set_instructions
6712:   friend class UntaggedFunction;
6713:   friend class CallSiteResetter;
6714:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
6717: class Context : public Object {
6788:   friend class Class;
6789:   friend class Object;
6792: // The ContextScope class makes it possible to delay the compilation of a local
6802: class ContextScope : public Object {
6887:   friend class Class;
6888:   friend class Object;
6891: // Class of special sentinel values:
6900: class Sentinel : public Object {
6910:   friend class Class;
6911:   friend class Object;
6914: class MegamorphicCache : public CallSiteData {
6948:   void EnsureContains(const Smi& class_id, const Object& target) const;
6949:   ObjectPtr Lookup(const Smi& class_id) const;
6956:   friend class Class;
6957:   friend class MegamorphicCacheTable;
6958:   friend class ProgramVisitor;
6963:   void InsertLocked(const Smi& class_id, const Object& target) const;
6965:   ObjectPtr LookupLocked(const Smi& class_id) const;
6967:   void InsertEntryLocked(const Smi& class_id, const Object& target) const;
6971:                               const Smi& class_id,
6980: class SubtypeTestCache : public Object {
6995:   void AddCheck(const Object& instance_class_id_or_signature,
7004:                 Object* instance_class_id_or_signature,
7016:                        Object* instance_class_id_or_signature,
7031:   bool HasCheck(const Object& instance_class_id_or_signature,
7080:   friend class Class;
7081:   friend class VMSerializationRoots;
7082:   friend class VMDeserializationRoots;
7085: class LoadingUnit : public Object {
7125:   friend class Class;
7128: class Error : public Object {
7136: class ApiError : public Error {
7154:   friend class Class;
7157: class LanguageError : public Error {
7220:   friend class Class;
7223: class UnhandledException : public Error {
7252:   friend class Class;
7253:   friend class ObjectStore;
7256: class UnwindError : public Error {
7276:   friend class Class;
7279: // Instance is the base class for all instance objects (aka the Object class
7281: class Instance : public Object {
7297:     const Class& cls = Class::Handle(clazz());
7371:   // class implementing a 'call' method, return true and set the function
7394:       const Class& method_cls,
7410:   static InstancePtr New(const Class& cls, Heap::Space space = Heap::kNew);
7418:   // only the class_id is different. So, it is safe to use subtype instances in
7467:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7479:   static InstancePtr NewFromCidAndSize(SharedClassTable* shared_class_table,
7485:   friend class ByteBuffer;
7486:   friend class Class;
7487:   friend class Closure;
7488:   friend class Pointer;
7489:   friend class DeferredObject;
7490:   friend class RegExp;
7491:   friend class StubCode;
7492:   friend class TypedDataView;
7493:   friend class InstanceSerializationCluster;
7494:   friend class InstanceDeserializationCluster;
7495:   friend class ClassDeserializationCluster;  // vtable
7496:   friend class InstanceMorpher;
7497:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7500: class LibraryPrefix : public Instance {
7535:   friend class Class;
7540: class TypeParameters : public Object {
7586:              bool are_class_type_parameters,
7614:   friend class Class;
7615:   friend class ClassFinalizer;
7616:   friend class Function;
7617:   friend class FunctionType;
7618:   friend class Object;
7619:   friend class Precompiler;
7623: class TypeArguments : public Instance {
7708:   // a raw (null) function type arguments, i.e. consider each class type
7775:       const Class& instantiator_class,
7791:   // Add the class name and URI of each type argument of this vector to the uris
7798:   // type from the various type argument vectors (class instantiator, function,
7876:   // If raw_instantiated is true, consider each class type parameter to be first
7890:   friend class AbstractType;
7891:   friend class Class;
7892:   friend class ClearTypeHashVisitor;
7893:   friend class Object;
7898: class AbstractType : public Instance {
7934:   virtual classid_t type_class_id() const;
7935:   virtual ClassPtr type_class() const;
7958:   // instantiation. Consider a class C<T> declaring a non-generic method
7960:   // generic function bar<B> as argument and its function type refers to class
8033:   // Add the class name and URI of each occuring type to the uris
8039:   // The name of this type's class, i.e. without the type argument names of this
8047:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
8050:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
8062:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
8078:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
8099:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
8102:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
8105:   bool IsMintType() const { return type_class_id() == kMintCid; }
8120:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
8175:   // NextFieldOffset() are required to register class _AbstractType.
8192:   friend class Class;
8193:   friend class Function;
8194:   friend class TypeArguments;
8197: // A Type consists of a class, possibly parameterized with type
8199: class Type : public AbstractType {
8202:     return OFFSET_OF(UntaggedType, type_class_id_);
8224:     ASSERT(type_class_id() != kIllegalCid);
8231:   virtual classid_t type_class_id() const;
8232:   virtual ClassPtr type_class() const;
8233:   void set_type_class(const Class& value) const;
8247:   // canonicalization (passed-in cls must match type_class()).
8248:   bool IsDeclarationTypeOf(const Class& cls) const;
8330:   // The finalized type of the given non-parameterized class.
8331:   static TypePtr NewNonParameterizedType(const Class& type_class);
8333:   static TypePtr New(const Class& clazz,
8350:   friend class Class;
8351:   friend class TypeArguments;
8352:   friend class ClearTypeHashVisitor;
8358: class FunctionType : public AbstractType {
8653:   friend class Class;
8654:   friend class ClearTypeHashVisitor;
8655:   friend class Function;
8662: class TypeRef : public AbstractType {
8686:     return AbstractType::Handle(type()).type_class_id();
8689:     return AbstractType::Handle(type()).type_class();
8728:   friend class Class;
8731: // A TypeParameter represents a type parameter of a parameterized class.
8735: // the class HashMap<K, V>. At compile time, the TypeParameter is not
8738: // as type argument (rather than type parameter) of the parameterized class.
8741: class TypeParameter : public AbstractType {
8763:   classid_t parameterized_class_id() const;
8764:   void set_parameterized_class_id(classid_t value) const;
8765:   ClassPtr parameterized_class() const;
8767:     return parameterized_class_id() != kFunctionCid;
8770:     return parameterized_class_id() == kFunctionCid;
8774:     return OFFSET_OF(UntaggedTypeParameter, parameterized_class_id_);
8831:   static const char* CanonicalNameCString(bool is_class_type_parameter,
8839:   // 'parameterized_class' is null for a function type parameter.
8840:   static TypeParameterPtr New(const Class& parameterized_class,
8850:   void set_parameterized_class(const Class& value) const;
8858:   friend class Class;
8859:   friend class ClearTypeHashVisitor;
8862: class Number : public Instance {
8879:   friend class Class;
8882: class Integer : public Number {
8954:   friend class Class;
8957: class Smi : public Integer {
8991:   static ClassPtr Class();
9017:     // Indicates this class cannot be extended by dart code.
9024:   friend class Api;  // For ValueFromRaw
9025:   friend class Class;
9026:   friend class Object;
9027:   friend class ReusableSmiHandleScope;
9028:   friend class Thread;
9031: class SmiTraits : AllStatic {
9043: class Mint : public Integer {
9073:   friend class Integer;
9074:   friend class MintMessageDeserializationCluster;
9085:   friend class Class;
9086:   friend class Number;
9089: // Class Double represents class Double in corelib_impl, which implements
9090: // abstract class double in corelib.
9091: class Double : public Number {
9123:   friend class Class;
9124:   friend class Number;
9128: class Symbol : public AllStatic {
9130:   static bool IsSymbolCid(Thread* thread, classid_t class_id);
9136: class String : public Instance {
9163:   class CodePointIterator : public ValueObject {
9487:   friend class Class;
9488:   friend class Symbols;
9489:   friend class StringSlice;  // SetHash
9491:   friend class CharArray;     // SetHash
9492:   friend class ConcatString;  // SetHash
9493:   friend class OneByteString;
9494:   friend class TwoByteString;
9495:   friend class ExternalOneByteString;
9496:   friend class ExternalTwoByteString;
9497:   friend class UntaggedOneByteString;
9498:   friend class RODataSerializationCluster;  // SetHash
9499:   friend class Pass2Visitor;                // Stack "handle"
9503: class StringHasher : ValueObject {
9528: class OneByteString : public AllStatic {
9654:   friend class Class;
9655:   friend class ExternalOneByteString;
9656:   friend class ImageWriter;
9657:   friend class String;
9658:   friend class StringHasher;
9659:   friend class Symbols;
9660:   friend class Utf8;
9661:   friend class OneByteStringMessageSerializationCluster;
9664: class TwoByteString : public AllStatic {
9774:   friend class Class;
9775:   friend class ImageWriter;
9776:   friend class String;
9777:   friend class StringHasher;
9778:   friend class Symbols;
9779:   friend class TwoByteStringMessageSerializationCluster;
9782: class ExternalOneByteString : public AllStatic {
9864:     // Indicates this class cannot be extended by dart code.
9868:   friend class Class;
9869:   friend class String;
9870:   friend class StringHasher;
9871:   friend class Symbols;
9872:   friend class Utf8;
9875: class ExternalTwoByteString : public AllStatic {
9953:     // Indicates this class cannot be extended by dart code.
9957:   friend class Class;
9958:   friend class String;
9959:   friend class StringHasher;
9960:   friend class Symbols;
9963: // Class Bool implements Dart core class bool.
9964: class Bool : public Instance {
9986:   friend class Class;
9987:   friend class Object;  // To initialize the true and false values.
9990: class Array : public Instance {
10114:   // Make the array immutable to Dart code by switching the class pointer
10150:   static ArrayPtr New(intptr_t class_id,
10191:   friend class Class;
10192:   friend class ImmutableArray;
10193:   friend class Object;
10194:   friend class String;
10195:   friend class MessageDeserializer;
10198: class ImmutableArray : public AllStatic {
10216:     // Indicates this class cannot be extended by dart code.
10224:   friend class Class;
10227: class GrowableObjectArray : public Instance {
10328:   friend class Array;
10329:   friend class Class;
10332: class Float32x4 : public Instance {
10365:   friend class Class;
10368: class Int32x4 : public Instance {
10398:   friend class Class;
10401: class Float64x2 : public Instance {
10428:   friend class Class;
10431: class PointerBase : public Instance {
10438: class TypedDataBase : public PointerBase {
10529:   friend class Class;
10544: class TypedData : public TypedDataBase {
10595:   static intptr_t MaxElements(intptr_t class_id) {
10596:     ASSERT(IsTypedDataClassId(class_id));
10597:     return (kSmiMax / ElementSizeInBytes(class_id));
10600:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
10601:     ASSERT(IsTypedDataClassId(class_id));
10603:            ElementSizeInBytes(class_id);
10606:   static TypedDataPtr New(intptr_t class_id,
10669:   // Therefore this method is private and the call-sites in this class need to
10677:   friend class Class;
10678:   friend class ExternalTypedData;
10679:   friend class TypedDataView;
10682: class ExternalTypedData : public TypedDataBase {
10700:   static intptr_t MaxElements(intptr_t class_id) {
10701:     ASSERT(IsExternalTypedDataClassId(class_id));
10702:     return (kSmiMax / ElementSizeInBytes(class_id));
10706:       intptr_t class_id,
10736:   friend class Class;
10739: class TypedDataView : public TypedDataBase {
10741:   static TypedDataViewPtr New(intptr_t class_id,
10743:   static TypedDataViewPtr New(intptr_t class_id,
10807:   friend class Class;
10808:   friend class Object;
10809:   friend class TypedDataViewDeserializationCluster;
10812: class ByteBuffer : public AllStatic {
10838: class Pointer : public Instance {
10874:   friend class Class;
10877: class DynamicLibrary : public Instance {
10903:   friend class Class;
10906: class LinkedHashBase : public Instance {
10941:   friend class Class;
10942:   friend class LinkedHashBaseDeserializationCluster;
10949: class LinkedHashMap : public LinkedHashBase {
11015:   class Iterator : ValueObject {
11055:   friend class Class;
11056:   friend class LinkedHashMapDeserializationCluster;
11059: class LinkedHashSet : public LinkedHashBase {
11125:   class Iterator : ValueObject {
11163:   friend class Class;
11166: class Closure : public Instance {
11263:   friend class Class;
11266: class Capability : public Instance {
11277:   friend class Class;
11280: class ReceivePort : public Instance {
11306:   friend class Class;
11309: class SendPort : public Instance {
11329:   friend class Class;
11334: class TransferableTypedDataPeer {
11361: class TransferableTypedData : public Instance {
11371:   friend class Class;
11374: class DebuggerStackTrace;
11377: class StackTrace : public Instance {
11431:   friend class Class;
11432:   friend class DebuggerStackTrace;
11435: class RegExpFlags {
11485: class RegExp : public Instance {
11504:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
11505:   class FlagsBits : public BitField<int8_t, intptr_t, kFlagsPos, kFlagsSize> {};
11661:   friend class Class;
11664: class WeakProperty : public Instance {
11692:   friend class Class;
11695: class MirrorReference : public Instance {
11726:   friend class Class;
11729: class UserTag : public Instance {
11762:   friend class Class;
11765: // Represents abstract FutureOr class in dart:async.
11766: class FutureOr : public Instance {
11782:   friend class Class;
11789:     return Smi::Class();
11792:   return IsolateGroup::Current()->class_table()->At(ptr()->GetClassId());
11942:                                 const Smi& class_id,
11945:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
12040: // This helper class can then be used via
12075: class ArrayOfTuplesView {
12079:   class Iterator;
12081:   class TupleView {
12107:     friend class Iterator;
12110:   class Iterator {
12160:     ArrayOfTuplesView<Class::InvocationDispatcherEntry,
84: // For AllStatic classes like OneByteString. Checks that
181:   static const ClassId kClassId = k##object##Cid;                              \
311:   inline ClassPtr clazz() const;
568:     // Internal names are the true names of classes, fields,
572:     // The names of core implementation classes (like _OneByteString)
577:     //   private constructor        -> _MyClass@6b3832b.
578:     //   private named constructor  -> _MyClass@6b3832b.named
588:     //   _MyClass@6b3832b.      -> _MyClass
589:     //   _MyClass@6b3832b.named -> _MyClass.named
595:     // the names of core implementation classes are remapped to their
600:     //   _MyClass@6b3832b.      -> _MyClass
601:     //   _MyClass@6b3832b.named -> _MyClass.named
841:   static ClassPtr
996:   static intptr_t host_instance_size(ClassPtr clazz) {
999:   static intptr_t target_instance_size(ClassPtr clazz) {
1071:     return UntaggedObject::ClassIdTag::is_valid(value);
1075:     ASSERT(value >= 0 && value < std::numeric_limits<classid_t>::max());
1078:   static intptr_t id_offset() { return OFFSET_OF(UntaggedClass, id_); }
1080:     return OFFSET_OF(UntaggedClass, num_type_arguments_);
1093:   ClassPtr Mixin() const;
1133:   // in superclass clauses.
1147:     return OFFSET_OF(UntaggedClass, declaration_type_);
1241:     return OFFSET_OF(UntaggedClass, host_type_arguments_field_offset_in_words_);
1251:     return OFFSET_OF(UntaggedClass, super_type_);
1255:   // |original_classes| only has an effect when reloading. If true and we
1256:   // are reloading, it will prefer the original classes to the replacement
1257:   // classes.
1258:   ClassPtr SuperClass(bool original_classes = false) const;
1317:   bool IsDartFunctionClass() const;
1320:   bool IsFutureClass() const;
1331:   static bool IsInFullSnapshot(ClassPtr cls) {
1376:   // |original_classes| only has an effect when reloading. If true and we
1377:   // are reloading, it will prefer the original classes to the replacement
1378:   // classes.
1379:   ArrayPtr OffsetToFieldMap(bool original_classes = false) const;
1437:     return RoundedAllocationSize(sizeof(UntaggedClass));
1448:     return ClassLoadingBits::decode(state_bits());
1472:     return ClassFinalizedBits::decode(state_bits()) ==
1473:                UntaggedClass::kFinalized ||
1474:            ClassFinalizedBits::decode(state_bits()) ==
1475:                UntaggedClass::kAllocateFinalized;
1481:     return ClassFinalizedBits::decode(state_bits()) ==
1482:            UntaggedClass::kAllocateFinalized;
1487:     return ClassFinalizedBits::decode(state_bits()) ==
1488:            UntaggedClass::kPreFinalized;
1523:   static uint16_t NumNativeFieldsOf(ClassPtr clazz) {
1600:   // Allocate instance classes.
1601:   static ClassPtr New(const Library& lib,
1606:   static ClassPtr NewNativeWrapper(const Library& library,
1610:   // Allocate the raw string classes.
1614:   // Allocate the raw TypedData classes.
1618:   // Allocate the raw TypedDataView/ByteDataView classes.
1622:   // Allocate the raw ExternalTypedData classes.
1626:   // Allocate the raw Pointer classes.
1668:   static int32_t host_instance_size_in_words(const ClassPtr cls) {
1672:   static int32_t target_instance_size_in_words(const ClassPtr cls) {
1680:   static int32_t host_next_field_offset_in_words(const ClassPtr cls) {
1684:   static int32_t target_next_field_offset_in_words(const ClassPtr cls) {
1692:   static int32_t host_type_arguments_field_offset_in_words(const ClassPtr cls) {
1697:       const ClassPtr cls) {
1722:   static ClassPtr NewCommon(intptr_t index);
1753:                                              UntaggedClass::ClassFinalizedState,
1757:                                            UntaggedClass::ClassLoadingState,
1817:   // This includes type arguments of a superclass and takes overlapping
1837:   static ClassPtr New(intptr_t id,
1843:   static ClassPtr NewInstanceClass();
1856: // Classification of type genericity according to type parameter owners.
1886:     return RoundedAllocationSize(sizeof(UntaggedPatchClass));
1905:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
1945:   classid_t expected_cid() const { return untag()->expected_cid_; }
1951:   static MonomorphicSmiableCallPtr New(classid_t expected_cid,
2028: // Object holding information about an IC: test classes and their
2075:   V(CheckClass)                                                                \
2112:   // Call site classification that is helpful for hot-reload. Call sites with
2396:   // to list the call site's observed receiver classes and targets.
2629:   ClassPtr Owner() const;
2631:   ClassPtr origin() const;
3614: // 'ProhibitsHoistingCheckClass' is true if this function deoptimized before on
3621:   V(ProhibitsHoistingCheckClass)                                               \
4036:   ClassPtr Owner() const;
4168:     StoreNonPointer<ClassIdTagType, ClassIdTagType, std::memory_order_relaxed>(
4261:     return LoadNonPointer<ClassIdTagType, std::memory_order_relaxed>(
4265:     StoreNonPointer<ClassIdTagType, ClassIdTagType, std::memory_order_relaxed>(
4594:   ClassDictionaryIterator(const Library& library,
4602:   ClassPtr GetNextClass();
4605:   void MoveToNextClass();
4609:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4681:   ClassPtr LookupClass(const String& name) const;
4682:   ClassPtr LookupClassAllowPrivate(const String& name) const;
4683:   ClassPtr SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4684:   ClassPtr LookupLocalClass(const String& name) const;
4821:            ((value >= 0) && (value < std::numeric_limits<classid_t>::max())));
4892:   // Eagerly compile all classes and functions in the library.
4895:   // Finalize all classes in all libraries.
4914:   // helper methods and classes. Allow look up of private classes.
5041:                                   const Array& classes_cache,
5106:   void set_classes_cache(const Array& cache) const;
5107:   ClassPtr LookupClass(Thread* thread, const Smi& name_index) const;
5108:   ClassPtr InsertClass(Thread* thread,
7480:                                        classid_t cid,
7689:   // Names of internal classes are mapped to their public interfaces.
7896: // AbstractType is an abstract superclass.
8022:   // Names of internal classes are mapped to their public interfaces.
8041:   StringPtr ClassName() const;
8681:            AbstractType::Handle(type()).HasTypeClass();
10463:   static intptr_t ElementSizeInBytes(classid_t cid) {
10467:   static TypedDataElementType ElementType(classid_t cid) {
10781:     const classid_t cid = typed_data.GetClassId();
11705:   ClassPtr GetClassReferent() const;
11786: ClassPtr Object::clazz() const {
12073: //     classes (e.g. 'Code', 'Smi', 'Object')
114:         HandleImpl(Thread::Current()->zone(), object::null(), kClassId));      \
117:     return static_cast<object&>(HandleImpl(zone, object::null(), kClassId));   \
121:         HandleImpl(Thread::Current()->zone(), ptr, kClassId));                 \
124:     return static_cast<object&>(HandleImpl(zone, ptr, kClassId));              \
128:         ZoneHandleImpl(Thread::Current()->zone(), object::null(), kClassId));  \
132:         ZoneHandleImpl(zone, object::null(), kClassId));                       \
136:         ZoneHandleImpl(Thread::Current()->zone(), ptr, kClassId));             \
139:     return static_cast<object&>(ZoneHandleImpl(zone, ptr, kClassId));          \
142:     return static_cast<object*>(ReadOnlyHandleImpl(kClassId));                 \
186:     obj->SetPtr(ptr, kClassId);                                                \
309:                                   : ptr()->untag()->GetClassId();
339:   // Object::DictionaryName() returns String::null(). Only subclasses
1132:   // dynamic and type parameters declared in superclasses filled in as declared
1289:     return direct_subclasses_unsafe();
1292:     return untag()->direct_subclasses();
1297:   void set_direct_subclasses(const GrowableObjectArray& subclasses) const;
1328:     return GetClassId(cls) == kClosureCid;
1463:     return SynthesizedClassBit::decode(state_bits());
1739:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1754:                                              kClassFinalizedPos,
1755:                                              kClassFinalizedSize> {};
1758:                                            kClassLoadingPos,
1759:                                            kClassLoadingSize> {};
1762:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
1888:   static bool IsInFullSnapshot(PatchClassPtr cls) {
1903:   static PatchClassPtr New();
2242:   void GetOneClassCheckAt(intptr_t index,
2248:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2249:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2261:   ICDataPtr AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2268:   ICDataPtr AsUnaryClassChecksSortedByCount() const;
3521:       return IsTypedDataViewClassId(klass.id());
4896:   static ErrorPtr FinalizeAllClasses();
4938:   void EnsureTopLevelClassIsFinalized() const;
4962:   void InitClassDictionary() const;
6448:     return owner->GetClassId();
6974:   static inline ObjectPtr GetClassId(const Array& array, intptr_t index);
7288:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
7897: // Subclasses of AbstractType are Type and TypeParameter.
8828:     return CanonicalNameCString(IsClassTypeParameter(), base(), index());
9301:     return ptr()->GetClassId() == kOneByteStringCid;
9305:     return ptr()->GetClassId() == kTwoByteStringCid;
9309:     return ptr()->GetClassId() == kExternalOneByteStringCid;
9313:     return ptr()->GetClassId() == kExternalTwoByteStringCid;
9317:     return IsExternalStringClassId(ptr()->GetClassId());
10061:   bool IsImmutable() const { return ptr()->GetClassId() == kImmutableArrayCid; }
10452:     return ElementSizeInBytes(ptr()->GetClassId()) * Length();
10456:     return ElementType(ptr()->GetClassId());
10460:     return element_size(ElementType(ptr()->GetClassId()));
10470:     } else if (IsTypedDataClassId(cid)) {
10474:     } else if (IsTypedDataViewClassId(cid)) {
10479:       ASSERT(IsExternalTypedDataClassId(cid));
10657:     intptr_t cid = obj.ptr()->GetClassId();
10658:     return IsTypedDataClassId(cid);
10716:     intptr_t cid = obj.ptr()->GetClassId();
10717:     return IsExternalTypedDataClassId(cid);
10763:     intptr_t cid = data.ptr()->GetClassId();
10764:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10765:     return IsExternalTypedDataClassId(cid);
10782:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10887:     intptr_t cid = obj.ptr()->GetClassId();
10888:     return IsFfiDynamicLibraryClassId(cid);
11798:   intptr_t cid = value->GetClassIdMayBeSmi();
11950:   return array.At((index * kEntryLength) + kClassIdIndex);
12019:   switch (str->GetClassId()) {
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-planes/combined.js: [ master, ]
5051:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
685:  * Find elements by tag or class name.
688:  * - {string} .className Class name.
5102:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12064:      * tags that have a specific class name.
12069:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13797:     'intro-finale/items-needle-thread',
13798:     'intro-finale/items-needle',
15100:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
15101:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
704:     if (params.className) {
705:       query += '.' + params.className;
710:     if (params.tagName && params.className) {
711:       var els = el.getElementsByClassName(params.className);
723:     } else if (params.className) {
724:       return el.getElementsByClassName(params.className);
727:     if (params.className) {
734:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
738:         if (el.className.match(regExp)) {
6532:                                             className: 'jsb' });
6547:                                             className: 'lsbb' });
12080:             el.className.indexOf(params.excludeClassName) == -1) {
12109:             (el.parentNode.className.indexOf('ds') != -1)) {
12121:                                             className: 'lsbb' });
12155:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12205:       // “View Google in Tablet | Classic” switcher.
709:   } else if (document.getElementsByClassName) {
12079:         if (!params.excludeClassName ||
12162:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-embedded/combined.js: [ master, ]
5024:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
686:  * Find elements by tag or class name.
689:  * - {string} .className Class name.
5075:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12033:      * tags that have a specific class name.
12038:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13843:             nItems = ['needle', 'noodles'];
15362:     'intro-finale/items-needle-thread',
15363:     'intro-finale/items-needle',
16665:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
16666:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
705:     if (params.className) {
706:       query += '.' + params.className;
711:     if (params.tagName && params.className) {
712:       var els = el.getElementsByClassName(params.className);
724:     } else if (params.className) {
725:       return el.getElementsByClassName(params.className);
728:     if (params.className) {
735:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
739:         if (el.className.match(regExp)) {
6505:                                             className: 'jsb' });
6520:                                             className: 'lsbb' });
12049:             el.className.indexOf(params.excludeClassName) == -1) {
12078:             (el.parentNode.className.indexOf('ds') != -1)) {
12090:                                             className: 'lsbb' });
12124:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12174:       // “View Google in Tablet | Classic” switcher.
710:   } else if (document.getElementsByClassName) {
12048:         if (!params.excludeClassName ||
12131:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/paymentservice/package-lock.json: [ master, ]
1058:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
112:             "create-error-class": "^3.0.2",
566:     "create-error-class": {
568:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1043:         "needle": {
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/currencyservice/package-lock.json: [ master, ]
1036:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
120:             "create-error-class": "^3.0.2",
529:     "create-error-class": {
531:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1021:         "needle": {
github.com/kubernetes/website:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/apache/activemq:activemq-web/src/main/resources/org/apache/activemq/web/prototype.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/googlearchive/caja:third_party/js/sunspider-benchmark/parse-only/concat-jquery-mootools-prototype.js: [ master, ]
2246: 	Expr.find.CLASS = function(match, context, isXML) {
3214: 	"class": "className",
5928: 	'class': 'className',
10691:         'class': 'className',
5425: 	var newClass = function(){
5437: 	newClass.prototype.constructor = newClass;
6957: 		var m, parsed = {classes: [], pseudos: [], attributes: []};
7118: 	byClass: function(self, klass){
8438:       var subclass = function() { };
8439:       subclass.prototype = parent.prototype;
10209:   classNames: function(element) {
10550:       className: 'class',
12641:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
12665: Element.ClassNames.prototype = {
10213:   hasClassName: function(element, className) {
10220:   addClassName: function(element, className) {
10227:   removeClassName: function(element, className) {
10234:   toggleClassName: function(element, className) {
710: 		// internal only, use addClass("class")
718: 		// internal only, use removeClass("class")
728: 		// internal only, use hasClass("class")
1658: 		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1667: 		"class": "className",
1773: 		CLASS: function(match, curLoop, inplace, result, not, isXML){
2007: 		CLASS: function(elem, match){
2008: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2203: 	div.innerHTML = "<p class='TEST'></p>";
2233: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2239: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
2245: 	Expr.order.splice(1, 0, "CLASS");
2686: 			// Filter the functions by class
4391: 	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2...(102 bytes skipped)...
5414: Script: Class.js
5415: 	Contains the Class Function for easily creating, extending, and implementing reusable Classes.
5421: function Class(params){
5436: 	newClass.constructor = Class;
5471: new Native({name: 'Class', initialize: Class}).extend({
5496: Class.implement({
5505: 		var mutator = Class.Mutators[key];
5518: 				proto[key] = Class.wrap(this, key, value);
5541: Class.Mutators = {
5546: 		this.prototype = Class.instantiate(parent);
5558: 			if (item instanceof Function) item = Class.instantiate(item);
5568: Script: Class.Extras.js
5575: var Chain = new Class({
5595: var Events = new Class({
5653: var Options = new Class({
7338: 	Class for creating, loading, and saving browser Cookies.
7347: var Cookie = new Class({
7414: var Swiff = new Class({
7513: var Fx = new Class({
7646: Fx.CSS = new Class({
7780: Fx.Tween = new Class({
7877: Fx.Morph = new Class({
8040: 	Powerful all purpose Request Class. Uses XMLHTTPRequest.
8046: var Request = new Class({
8235: 	Extends the basic Request Class with additional methods for interacting with HTML responses.
8241: Request.HTML = new Class({
8355: 	Extends the basic Request Class with additional methods for sending and receiving JSON data.
8361: Request.JSON = new Class({
8423: var Class = {
8433:     Object.extend(klass, Class.Methods);
8456: Class.Methods = {
8673: var PeriodicalExecuter = Class.create({
8939: var Template = Class.create({
9376: var Hash = Class.create(Enumerable, (function() {
9473: var ObjectRange = Class.create(Enumerable, {
9547: Ajax.Base = Class.create({
9569: Ajax.Request = Class.create(Ajax.Base, {
9742: Ajax.Response = Class.create({
9816: Ajax.Updater = Class.create(Ajax.Request, {
9852: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
10060:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
11100: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
11104: var Selector = Class.create({
11292:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
11592:       var needle = ' ' + className + ' ';
11596:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
12083: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
12100: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12106: Form.Observer = Class.create(Abstract.TimedObserver, {
12114: Abstract.EventObserver = Class.create({
12153: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12159: Form.EventObserver = Class.create(Abstract.EventObserver, {
12631:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
12664: Element.ClassNames = Class.create();
405: 	hasClass: function( selector ) {
709: 	className: {
711: 		add: function( elem, classNames ) {
712: 			jQuery.each((classNames || "").split(/\s+/), function(i, className){
713: 				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
714: 					elem.className += (elem.className ? " " : "") + className;
719: 		remove: function( elem, classNames ) {
721: 				elem.className = classNames !== undefined ?
722: 					jQuery.grep(elem.className.split(/\s+/), function(className){
723: 						return !jQuery.className.has( classNames, className );
729: 		has: function( elem, className ) {
730: 			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
1225: 	addClass: function( classNames ) {
1226: 		jQuery.className.add( this, classNames );
1229: 	removeClass: function( classNames ) {
1230: 		jQuery.className.remove( this, classNames );
1233: 	toggleClass: function( classNames, state ) {
1235: 			state = !jQuery.className.has( this, classNames );
1236: 		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1782: 					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
2235: 	// Opera can't find a second classname (in 9.6)
2240: 	div.lastChild.className = "e";
5427: 		if (newClass._prototyping) return this;
5434: 	newClass.implement(params);
5439: 	return newClass;
5569: 	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
6041: 	hasClass: function(className){
6042: 		return this.className.contains(className, ' ');
6045: 	addClass: function(className){
6046: 		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
6050: 	removeClass: function(className){
6051: 		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
6055: 	toggleClass: function(className){
6056: 		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
6961: 				parsed.classes.push(cn);
6970: 		if (!parsed.classes.length) delete parsed.classes;
6973: 		if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
6985: 		if (parsed.classes){
6986: 			for (i = parsed.classes.length; i--; i){
6987: 				var cn = parsed.classes[i];
6988: 				if (!Selectors.Filters.byClass(item, cn)) return false;
7119: 		return (self.className && self.className.contains(klass, ' '));
7464: 			properties.classid = 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000';
7507: 	Contains the basic animation logic to be extended by all other Fx Classes.
7942: 	Contains a set of advanced transitions to be used with any of the Fx Classes.
8434:     klass.superclass = parent;
8440:       klass.prototype = new subclass;
8458:     var ancestor   = this.superclass && this.superclass.prototype;
10210:     return new Element.ClassNames(element);
10215:     var elementClassName = element.className;
10216:     return (elementClassName.length > 0 && (elementClassName == className ||
10217:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
10222:     if (!element.hasClassName(className))
10223:       element.className += (element.className ? ' ' : '') + className;
10229:     element.className = element.className.replace(
10230:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
10236:     return element[element.hasClassName(className) ?
10237:       'removeClassName' : 'addClassName'](className);
11023:   function findDOMClass(tagName) {
11055:       var klass = findDOMClass(tag);
11386:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
11414:     className:    /^\.([\w\-\*]+)(\b|$)/,
11427:     className: function(element, matches) {
11585:     className: function(nodes, root, className, combinator) {
11587:       return Selector.handlers.byClassName(nodes, root, className);
11590:     byClassName: function(nodes, root, className) {
11594:         nodeClassName = node.className;
12635:   function(element, className) {
12636:     className = className.toString().strip();
12637:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
12639:   } : function(element, className) {
12640:     className = className.toString().strip();
12642:     if (!classNames && !className) return elements;
12645:     className = ' ' + className + ' ';
12648:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
12649:           (classNames && classNames.all(function(name) {
12657:   return function(className, parentElement) {
12658:     return $(parentElement || document.body).getElementsByClassName(className);
12671:     this.element.className.split(/\s+/).select(function(name) {
12676:   set: function(className) {
12677:     this.element.className = className;
12680:   add: function(classNameToAdd) {
12681:     if (this.include(classNameToAdd)) return;
12682:     this.set($A(this).concat(classNameToAdd).join(' '));
12685:   remove: function(classNameToRemove) {
12686:     if (!this.include(classNameToRemove)) return;
12687:     this.set($A(this).without(classNameToRemove).join(' '));
12695: Object.extend(Element.ClassNames.prototype, Enumerable);
2231: if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2236: 	if ( div.getElementsByClassName("e").length === 0 )
2242: 	if ( div.getElementsByClassName("e").length === 1 )
2247: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248: 			return context.getElementsByClassName(match[1]);
4686: 			return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925));
4698: 			return (document.getBoxObjectFor == undefined) ? false : ((document.getElementsByClassName) ? 19 : 18);
8435:     klass.subclasses = [];
8441:       parent.subclasses.push(klass);
11428:       return Element.hasClassName(element, matches[1]);
11593:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
11595:         if (nodeClassName.length == 0) continue;
12629: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
12634:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/ampproject/amp.dev:pixi/cloud-function/package-lock.json: [ future, ]
1051: 				"needle": "bin/needle"
1249: 				"needle": "^2.5.2",
2538: 				"needle": "^2.5.2",
1475: 				"mkdirp-classic": "^0.5.2",
2718: 				"mkdirp-classic": "^0.5.2",
1041: 		"node_modules/needle": {
1043: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.6.0.tgz",
1057: 		"node_modules/needle/node_modules/debug": {
2390: 		"needle": {
2392: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.6.0.tgz",
1020: 		"node_modules/mkdirp-classic": {
1022: 			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
2375: 		"mkdirp-classic": {
2377: 			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
chromium.googlesource.com/chromium/src:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
13999: const Class = function(info, mixin) {
6658:  function superPropertiesClass(constructor) {
12323: DomApiNative.prototype.classList;
13693:     static _finalizeClass() {
229:  * Wraps an ES6 class expression mixin such that the mixin is only applied
234:  * @param {T} mixin ES6 class expression mixin to wrap
257:     // copy inherited mixin set from the extended class, or the base class
283: class Debouncer {
1761: class DomModule extends HTMLElement {
2399:  * Element class mixin that provides basic meta-programming for creating one
2404:  * once at class definition time to create property accessors for properties
2413:  * @summary Element class mixin for reacting to property changes from
2419:      * @param {function(new:T)} superClass Class to apply mixin to.
2430:   class PropertiesChanged extends superClass {
2879:         if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
2996:  * Element class mixin that provides basic meta-programming for creating one
3005:  * -   Implement the `_propertiesChanged` callback on the class.
3006:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
3022:  * @summary Element class mixin for reacting to property changes from
3042:   class PropertyAccessors extends base {
3361:  * @summary Element class mixin that provides basic template parsing and stamping
3366:      * @param {function(new:T)} superClass Class to apply mixin to.
3376:   class TemplateStamp extends superClass {
4197:  * @param {Function} constructor Class that `_parseTemplate` is currently
4234:  * @param {Function} constructor Class that `_parseTemplate` is currently
4764:  * Element class mixin that provides meta-programming for Polymer's template
4768:  * property effects to an element class:
4795:  * @summary Element class mixin that provides meta-programming for Polymer's
4816:   class PropertyEffects extends propertyEffectsBase {
5381:      * Runs each class of effects for the batch of changed properties in
5944:     // -- static class methods ------------
6113:      *   bound template for the class. When true (as passed from
6316:           // when a class$ binding's initial literal value is set.
6317:           if (name == 'class' && node.hasAttribute('class')) {
6542: class HostStack {
6590:  * Registers a class prototype for telemetry purposes.
6652:   * Returns the super class constructor for the given class, if it is an
6656:   * @return {?PropertiesMixinConstructor} Super class constructor
6661:    // Note, the `PropertiesMixin` class below only refers to the class
6671:   * given class. Properties not in object format are converted to at
6701:  class PropertiesMixin extends base {
6736:     * Finalize an element class. This includes ensuring property
6738:     * `finalize` and finalizes the class constructor.
6754:     * @return {Object} Object containing properties for this class
6846:  * Element class mixin that provides the core API for Polymer's meta-programming
6851:  * used to configure Polymer's features for the class:
6887:  * The base class provides default implementations for the following standard
6906:  * @property importPath {string} Set to the value of the class's static
6910:  * @summary Element class mixin that provides the core API for Polymer's
6929:    * @param {PolymerElementConstructor} constructor Element class
6930:    * @return {PolymerElementProperties} Flattened properties for this class
6952:    * @param {PolymerElementConstructor} constructor Element class
6953:    * @return {Array} Array containing own observers for the given class
7016:    * @param {!PolymerElement} proto Element class prototype to add accessors
7070:    * @param {PolymerElementConstructor} klass Element class
7141:   class PolymerElement extends polymerElementBase {
7199:      *   this class
7224:      * Note that when subclassing, if the super class overrode the default
7229:      * If a subclass would like to modify the super class template, it should
7235:      *   class MySubClass extends MySuperClass {
7251:       // - constructor.template (this getter): the template for the class.
7253:       //     dom-module, or from the super class's template (or can be overridden
7303:      * @return {string} The import path for this element class
7337:      * Overrides the default `PropertyAccessors` to ensure class
7617:  * Class representing a static string value which can be used to filter
7618:  * strings by asseting that they have been created via this class. The
7621: class LiteralString {
7688:  *         <div class="shadowed">${this.partialTemplate}</div>
7716:  * Base class that provides the core API for Polymer's meta-programming
7726:  * @summary Custom element base class that provides the core API for Polymer's
7763:  * Element class mixin to skip strict dirty-checking for objects and arrays
7798:  * @summary Element class mixin to skip strict dirty-checking for objects
7808:   class MutableData extends superClass {
7837:  * Element class mixin to add the optional ability to skip strict
7873:  * @summary Element class mixin to optionally skip strict dirty-checking
7883:   class OptionalMutableData extends superClass {
7936: // Base class for HTMLTemplateElement extension that has property effects
7938: // class only because Babel (incorrectly) requires super() in the class
7980:  * Base class for TemplateInstance.
7985: const templateInstanceBase = PropertyEffects(class {});
7993: class TemplateInstanceBase extends templateInstanceBase {
8215:  * @suppress {missingProperties} class.prototype is not defined for some reason
8231:    * Anonymous class created by the templatize
8235:   let klass = class extends templatizerBase { };
8244:  * @suppress {missingProperties} class.prototype is not defined for some reason
8249:     // Provide data API and property effects on memoized template class
8259:         class TemplatizedTemplate extends templatizedBase {};
8329:  * Returns an anonymous `PropertyEffects` class bound to the
8330:  * `<template>` provided.  Instancing the class will result in the
8350:  *    method on the generated class should be called to forward host
8359:  * - `mutableData`: When `true`, the generated class will skip strict
8389:  * `templatize()` return the same class for all duplicates of a template.
8390:  * The class returned from `templatize()` is generated only once using
8402:  * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
8420:   // Get memoized base class for the prototypical template, which
8433:   // Subclass base class and add reference for this specific template
8435:   let klass = class TemplateInstance extends baseClass {};
8550: class DomIf extends PolymerElement {
8850:  * class EmployeeList extends PolymerElement {
8921: class DomRepeat extends domRepeatBase {
9592: class StyleNode {
10225: class MixinMap {
10258: class ApplyShim {
10834: class CustomStyleInterface {
10959: class ApplyShimInterface {
11171:  * Element class mixin that provides API for adding Polymer's cross-platform
11181:  * @summary Element class mixin that provides API for adding Polymer's
11188:      * @param {function(new:T)} superClass Class to apply mixin to.
11197:       class GestureEventListeners extends superClass {
11668:  * Class that listens for changes (additions or removals) to
11689:  * class TestSelfObserve extends PolymerElement {
11705:  * @summary Class that listens for changes (additions or removals) to
11709: let FlattenedNodesObserver = class {
11989:  * Node API wrapper class returned from `Polymer.dom.(target)` when
11994: class DomApiNative {
12207:  * Event API wrapper class returned from `dom.(target)` when
12210: class EventApi {
12338:   class Wrapper extends window['ShadyDOM']['Wrapper'] {}
12444:  * Element class mixin that provides Polymer's "legacy" API intended to be
12455:  * @summary Element class mixin that provides Polymer's "legacy" API
12485:   class LegacyElement extends legacyElementBase {
12503:      *  closure for some reason even in a static method, rather than the class
12587:      * add support for class initialization via the `_registered` callback.
12613:      * Users may override this method to perform class registration time
12615:      * only once for the class.
13316:      * Toggles a CSS class on or off.
13318:      * @param {string} name CSS class name
13319:      * @param {boolean=} bool Boolean to force the class on or off.
13320:      *    When unspecified, the state of the class will be reversed.
13543:  * Applies a "legacy" behavior or array of behaviors to the provided class.
13552:  * @param {function(new:T)} klass Element class.
13553:  * @return {?} Returns a new Element class extended by the
13583: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
13584: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
13656:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
13657:   made. The list of behaviors was previously made into one generated class per
13662:   The generated class is directly tied to the info object and behaviors
13677:  * @param {function(new:HTMLElement)} Base base class to extend with info object
13679:  * @return {function(new:HTMLElement)} Generated class
13685:   // manages behavior and lifecycle processing (filled in after class definition)
13690:   class PolymerGenerated extends Base {
13772:       // only proceed if the generated class' prototype has not been registered.
13778:         // copy properties onto the generated class lazily if we're optimizing,
13783:         // and not the generated class prototype; if the element has been
13899:     // NOTE: ensure the behavior is extending a class with
13906:     // get flattened, deduped list of behaviors *not* already on super class
13930:  * Generates a class that extends `LegacyElement` based on the
13934:  * to the generated class.
13993:  *   to become class methods.
13995:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
13997:  * @return {function(new:HTMLElement)} Generated class
14001:     console.warn('Polymer.Class requires `info` argument');
14111:  * Legacy class factory and registration helper for defining Polymer
14116:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
14117:  *     customElements.define(info.is, Class(info));
14119:  * See `Class` for details on valid legacy metadata format for `info`.
14125:  *   to become class methods.
14126:  * @return {function(new: HTMLElement)} Generated class
14130:   // if input is a `class` (aka a function with a prototype), use the prototype
14136:     klass = Polymer.Class(info);
14142: Polymer.Class = Class;
14218:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
14224:    * @param {boolean=} mutableData When `true`, the generated class will skip
14243:    * returned is an instance of the anonymous class generated by `templatize`
14316: class DomBind extends domBindBase {
14456:   class ArraySelectorMixin extends elementBase {
14774:  * class EmployeeList extends PolymerElement {
14827: class ArraySelector extends baseArraySelector {
14972: class CustomStyle extends HTMLElement {
2403:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
2420:      * @return {function(new:T)} superClass with mixin applied.
2422:     (superClass) => {
2426:    * @mixinClass
3025: const PropertyAccessors = dedupingMixin(superClass => {
3033:    const base = PropertiesChanged(superClass);
3037:    * @mixinClass
3367:      * @return {function(new:T)} superClass with mixin applied.
3369:     (superClass) => {
3373:    * @mixinClass
4798: const PropertyEffects = dedupingMixin(superClass => {
4807:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
4811:    * @mixinClass
5249:      * Overrides superclass implementation.
6261:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6295:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6356:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6642: const PropertiesMixin = dedupingMixin(superClass => {
6649:  const base = PropertiesChanged(superClass);
6696:   * @mixinClass
6706:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6718:     * Finalizes an element definition, including ensuring any super classes
6721:     * `_finalizeClass` to finalize each constructor in the prototype chain.
6726:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6731:        this._finalizeClass();
6742:    static _finalizeClass() {
6751:     * from super classes. Properties not in object format are converted to
6760:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6973:    * these values may not be changed. For example, a subclass cannot
7009:    * reflectToAttribute property not do so in a subclass. We've chosen to
7011:    * For example, a readOnly effect generates a special setter. If a subclass
7136:    * @mixinClass
7152:      * Override of PropertiesMixin _finalizeClass to create observers and
7156:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7158:     static _finalizeClass() {
7159:       super._finalizeClass();
7225:      * implementation and the subclass would like to provide an alternate
7240:      *         subContent.textContent = 'This came from MySubClass';
7258:       //     constructor.template, saved in _finalizeClass(). Note that before
7271:           // Next look for superclass template (call the super impl this
7272:           // way so that `this` points to the superclass)
7567:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7583:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7801: const MutableData = dedupingMixin(superClass => {
7805:    * @mixinClass
7876: const OptionalMutableData = dedupingMixin(superClass => {
7879:    * @mixinClass
7971: // Applies a DataTemplate subclass to a <template> instance
8217: function createTemplatizerClass(template, templateInfo, options) {
8250:     let klass = templateInfo.templatizeTemplateClass;
8258:       klass = templateInfo.templatizeTemplateClass =
8426:   let baseClass = templateInfo.templatizeInstanceClass;
8427:   if (!baseClass) {
8428:     baseClass = createTemplatizerClass(template, templateInfo, options);
8429:     templateInfo.templatizeInstanceClass = baseClass;
8502:  * Forces several classes of asynchronously queued tasks to flush:
10091:         // remove build comment so it is not needlessly copied into every element instance
11189:      * @return {function(new:T)} superClass with mixin applied.
11191:     (superClass) => {
11194:        * @mixinClass
12347:   // Note, `classList` is here only for legacy compatibility since it does not
12350:     'classList'
12382:   // Properties that should return the logical, not composed tree. Note, `classList`
12389:     'childNodes', 'children', 'classList'
12480:    * @mixinClass
13325:     toggleClass(name, bool, node) {
13328:         bool = !node.classList.contains(name);
13331:         node.classList.add(name);
13333:         node.classList.remove(name);
13653: /* Note about construction and extension of legacy classes.
13659:   manually. Note, there may *still* be multiple generated classes in the
13664:   behaviors not active on the superclass. In order to call through to the
13672:   and not `_finalizeClass`.
13692:     // explicitly not calling super._finalizeClass
13694:       // if calling via a subclass that hasn't been generated, pass through to super
13696:         super._finalizeClass();
13776:         // ensure superclass is registered first.
14441: let ArraySelectorMixin = dedupingMixin(superClass => {
14448:   let elementBase = ElementMixin(superClass);
14452:    * @mixinClass
3212:      * `__dataProto`, and it is up to the subclasser to decide how/when
6850:  * Subclassers may provide the following static getters to return metadata
6975:    * by subclasses.
7008:    * effects via subclassing. For example, a user might want to make a
13558:   return GenerateClassFromInfo({}, LegacyElementMixin(klass), behaviors);
13683: function GenerateClassFromInfo(info, Base, behaviors) {
14005:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
chromium.googlesource.com/ios-chromium-mirror:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
github.com/apache/trafficcontrol:traffic_portal/app/src/package-lock.json: [ master, ]
1251:                         "needle": "^2.2.1",
100:                 "class-utils": "^0.3.5",
718:                 "posix-character-classes": "^0.1.0",
384:         "class-utils": {
386:             "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1234:                 "needle": {
2213:         "posix-character-classes": {
2215:             "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
chromium.googlesource.com/chromium/src/third_party:polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
android.googlesource.com/platform/external/free-image:Source/LibRawLite/dcraw/dcraw.c: [ master, ]
153: #define CLASS
99:    access them are prefixed with "CLASS".  Note that a thread-safe
100:    C++ class cannot have non-const static local variables.
217: int CLASS fc (int row, int col)
243: 	      char *needle, size_t needlelen)
247:     if (!memcmp (c, needle, needlelen))
254: void CLASS merror (void *ptr, char *where)
261: void CLASS derror()
273: ushort CLASS sget2 (uchar *s)
281: ushort CLASS get2()
288: unsigned CLASS sget4 (uchar *s)
297: unsigned CLASS get4()
304: unsigned CLASS getint (int type)
309: float CLASS int_to_float (int i)
316: double CLASS getreal (int type)
340: void CLASS read_shorts (ushort *pixel, int count)
347: void CLASS canon_black (double dark[2])
361: void CLASS canon_600_fixed_wb (int temp)
382: int CLASS canon_600_color (int ratio[2], int mar)
411: void CLASS canon_600_auto_wb()
453: void CLASS canon_600_coeff()
477: void CLASS canon_600_load_raw()
518: void CLASS remove_zeroes()
535: int CLASS canon_s2is()
546: void CLASS canon_a5_load_raw()
573: unsigned CLASS getbits (int nbits)
592: void CLASS init_decoder()
624: uchar * CLASS make_decoder (const uchar *source, int level)
650: void CLASS crw_init_tables (unsigned table)
720: int CLASS canon_has_lowbits()
735: void CLASS canon_compressed_load_raw()
817:   struct CLASS decode *huff[6];
821: int CLASS ljpeg_start (struct jhead *jh, int info_only)
873: int CLASS ljpeg_diff (struct decode *dindex)
888: ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
925: void CLASS lossless_jpeg_load_raw()
970: void CLASS canon_sraw_load_raw()
1037: void CLASS adobe_copy_pixel (int row, int col, ushort **rp)
1061: void CLASS adobe_dng_load_raw_lj()
1090: void CLASS adobe_dng_load_raw_nc()
1111: void CLASS pentax_tree()
1131: void CLASS pentax_k10_load_raw()
1148: void CLASS nikon_compressed_load_raw()
1221: int CLASS nikon_is_compressed()
1236: int CLASS nikon_e995()
1254: int CLASS nikon_e2100()
1269: void CLASS nikon_3700()
1295: int CLASS minolta_z2()
1308: void CLASS nikon_e900_load_raw()
1327: void CLASS fuji_load_raw()
1353: void CLASS jpeg_thumb (FILE *tfp);
1355: void CLASS ppm_thumb (FILE *tfp)
1367: void CLASS layer_thumb (FILE *tfp)
1384: void CLASS rollei_thumb (FILE *tfp)
1402: void CLASS rollei_load_raw()
1428: int CLASS bayer (unsigned row, unsigned col)
1433: void CLASS phase_one_flat_field (int is_float, int nc)
1477: void CLASS phase_one_correct()
1601: void CLASS phase_one_load_raw()
1628: unsigned CLASS ph1_bits (int nbits)
1643: void CLASS phase_one_load_raw_c()
1694: void CLASS hasselblad_load_raw()
1726: void CLASS leaf_hdr_load_raw()
1753: void CLASS unpacked_load_raw();
1755: void CLASS sinar_4shot_load_raw()
1790: void CLASS imacon_full_load_raw()
1799: void CLASS packed_12_load_raw()
1837: void CLASS unpacked_load_raw()
1855: void CLASS nokia_load_raw()
1879: unsigned CLASS pana_bits (int nbits)
1895: void CLASS panasonic_load_raw()
1918: void CLASS olympus_e300_load_raw()
1945: void CLASS olympus_e410_load_raw()
1986: void CLASS minolta_rd175_load_raw()
2014: void CLASS casio_qv5700_load_raw()
2034: void CLASS quicktake_100_load_raw()
2101: const int * CLASS make_decoder_int (const int *source, int level)
2118: int CLASS radc_token (int tree)
2164: void CLASS kodak_radc_load_raw()
2233: void CLASS kodak_jpeg_load_raw() {}
2249: void CLASS kodak_jpeg_load_raw()
2290: void CLASS kodak_dc120_load_raw()
2306: void CLASS eight_bit_load_raw()
2331: void CLASS kodak_yrgb_load_raw()
2355: void CLASS kodak_262_load_raw()
2404: int CLASS kodak_65000_decode (short *out, int bsize)
2450: void CLASS kodak_65000_load_raw()
2466: void CLASS kodak_ycbcr_load_raw()
2493: void CLASS kodak_rgb_load_raw()
2509: void CLASS kodak_thumb_load_raw()
2519: void CLASS sony_decrypt (unsigned *data, int len, int start, int key)
2536: void CLASS sony_load_raw()
2569: void CLASS sony_arw_load_raw()
2589: void CLASS sony_arw2_load_raw()
2630: void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
2696: void CLASS smal_v6_load_raw()
2709: int CLASS median4 (int *p)
2722: void CLASS fill_holes (int holes)
2748: void CLASS smal_v9_load_raw()
2770: void CLASS foveon_decoder (unsigned size, unsigned code)
2801: void CLASS foveon_thumb (FILE *tfp)
2840: void CLASS foveon_load_camf()
2854: void CLASS foveon_load_raw()
2892: const char * CLASS foveon_camf_param (const char *block, const char *param)
2914: void * CLASS foveon_camf_matrix (unsigned dim[3], const char *name)
2948: int CLASS foveon_fixed (void *ptr, int size, const char *name)
2960: float CLASS foveon_avg (short *pix, int range[2], float cfilt)
2974: short * CLASS foveon_make_curve (double max, double mul, double filt)
2993: void CLASS foveon_make_curves
3004: int CLASS foveon_apply_curve (short *curve, int i)
3012: void CLASS foveon_interpolate()
3415: void CLASS bad_pixels (char *fname)
3474: void CLASS subtract (char *fname)
3514: void CLASS pseudoinverse (double (*in)[3], double (*out)[3], int size)
3543: void CLASS cam_xyz_coeff (double cam_xyz[4][3])
3567: void CLASS colorcheck()
3660: void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
3671: void CLASS wavelet_denoise()
3746: void CLASS scale_colors()
3853: void CLASS pre_interpolate()
3887: void CLASS border_interpolate (int border)
3909: void CLASS lin_interpolate()
3955:    described in http://scien.stanford.edu/class/psych221/projects/99/tingchen/algodep/vargra.html
3960: void CLASS vng_interpolate()
4089: void CLASS ppg_interpolate()
4146: void CLASS ahd_interpolate()
4271: void CLASS median_filter()
4299: void CLASS blend_highlights()
4337: void CLASS recover_highlights()
4414: void CLASS tiff_get (unsigned base,
4425: void CLASS parse_thumb_note (int base, unsigned toff, unsigned tlen)
4438: int CLASS parse_tiff_ifd (int base);
4440: void CLASS parse_makernote (int base, int uptag)
4688:       load_raw = &CLASS olympus_e410_load_raw;
4716: void CLASS get_timestamp (int reversed)
4737: void CLASS parse_exif (int base)
4768: void CLASS parse_gps (int base)
4789: void CLASS romm_coeff (float romm_cam[3][3])
4803: void CLASS parse_mos (int offset)
4868: void CLASS linear_table (unsigned len)
4878: void CLASS parse_kodak_ifd (int base)
4909: void CLASS parse_minolta (int base);
4911: int CLASS parse_tiff_ifd (int base)
4982: 	load_raw = &CLASS panasonic_load_raw;
5033: 	  load_raw = &CLASS sinar_4shot_load_raw;
5039: 	  load_raw = &CLASS sony_arw_load_raw;
5173: 	load_raw = &CLASS imacon_full_load_raw;
5176: 	  load_raw = &CLASS unpacked_load_raw;
5284: 	load_raw = &CLASS packed_12_load_raw;
5319: void CLASS parse_tiff (int base)
5365: 	  case  8: load_raw = &CLASS eight_bit_load_raw;	break;
5366: 	  case 12: load_raw = &CLASS packed_12_load_raw;
5371: 	  case 16: load_raw = &CLASS unpacked_load_raw;		break;
5374: 	  load_raw = &CLASS olympus_e300_load_raw;
5377: 	load_raw = &CLASS lossless_jpeg_load_raw;		break;
5379: 	load_raw = &CLASS kodak_262_load_raw;			break;
5381: 	load_raw = &CLASS sony_arw2_load_raw;
5385: 	load_raw = &CLASS sony_arw_load_raw;			break;
5389: 	load_raw = &CLASS packed_12_load_raw;			break;
5391: 	load_raw = &CLASS nikon_compressed_load_raw;		break;
5393: 	load_raw = &CLASS pentax_k10_load_raw;			break;
5396: 	  case 2: load_raw = &CLASS kodak_rgb_load_raw;   filters = 0;  break;
5397: 	  case 6: load_raw = &CLASS kodak_ycbcr_load_raw; filters = 0;  break;
5398: 	  case 32803: load_raw = &CLASS kodak_65000_load_raw;
5424: 	write_thumb = &CLASS layer_thumb;
5428: 	  thumb_load_raw = &CLASS kodak_thumb_load_raw;
5430: 	  write_thumb = &CLASS ppm_thumb;
5434: 		&CLASS kodak_ycbcr_load_raw : &CLASS kodak_rgb_load_raw;
5439: void CLASS parse_minolta (int base)
5479: void CLASS parse_external_jpeg()
5529: void CLASS ciff_block_1030()
5553: void CLASS parse_ciff (int offset, int length)
5657: void CLASS parse_rollei()
5692:   write_thumb = &CLASS rollei_thumb;
5695: void CLASS parse_sinar_ia()
5720:   load_raw = &CLASS unpacked_load_raw;
5723:   write_thumb = &CLASS ppm_thumb;
5727: void CLASS parse_phase_one (int base)
5782: 	&CLASS phase_one_load_raw : &CLASS phase_one_load_raw_c;
5794: void CLASS parse_fuji (int offset)
5821: int CLASS parse_jpeg (int offset)
5847: void CLASS parse_riff()
5887: void CLASS parse_smal (int offset, int fsize)
5902:   if (ver == 6) load_raw = &CLASS smal_v6_load_raw;
5903:   if (ver == 9) load_raw = &CLASS smal_v9_load_raw;
5906: void CLASS parse_cine()
5924:     case  8:  load_raw = &CLASS eight_bit_load_raw;  break;
5925:     case 16:  load_raw = &CLASS  unpacked_load_raw;
5955: char * CLASS foveon_gets (int offset, char *str, int len)
5965: void CLASS parse_foveon()
6000: 	  write_thumb = &CLASS jpeg_thumb;
6006: 	  write_thumb = &CLASS foveon_thumb;
6054: void CLASS adobe_coeff (char *make, char *model)
6499: void CLASS simple_coeff (int index)
6519: short CLASS guess_byte_order (int words)
6542: void CLASS identify()
6633:   write_thumb = &CLASS jpeg_thumb;
6718:     load_raw = &CLASS nokia_load_raw;
6777:       load_raw = &CLASS adobe_dng_load_raw_nc;
6779:       load_raw = &CLASS adobe_dng_load_raw_lj;
6784: 	&CLASS lossless_jpeg_load_raw : &CLASS canon_compressed_load_raw;
6787:       load_raw = &CLASS packed_12_load_raw;
6792:     load_raw = &CLASS packed_12_load_raw;
6802:     load_raw = &CLASS foveon_load_raw;
6810:     load_raw = &CLASS canon_sraw_load_raw;
6818:     load_raw = &CLASS canon_600_load_raw;
6827:     load_raw = &CLASS canon_a5_load_raw;
6834:     load_raw = &CLASS canon_a5_load_raw;
6840:     load_raw = &CLASS canon_a5_load_raw;
6848:     load_raw = &CLASS canon_a5_load_raw;
6856:     load_raw = &CLASS canon_a5_load_raw;
6864:     load_raw = &CLASS canon_a5_load_raw;
6874:     load_raw = &CLASS canon_a5_load_raw;
6882:     load_raw = &CLASS canon_a5_load_raw;
6890:     load_raw = &CLASS canon_a5_load_raw;
6898:     load_raw = &CLASS canon_a5_load_raw;
6906:     load_raw = &CLASS canon_a5_load_raw;
6914:     load_raw = &CLASS canon_a5_load_raw;
6922:     load_raw = &CLASS canon_a5_load_raw;
7066:       load_raw = &CLASS packed_12_load_raw;
7089:     load_raw = &CLASS nikon_e900_load_raw;
7101:     load_raw = &CLASS nikon_e900_load_raw;
7110:     load_raw = &CLASS packed_12_load_raw;
7136:     load_raw = &CLASS packed_12_load_raw;
7157:     load_raw = &CLASS packed_12_load_raw;
7173:     load_raw = &CLASS packed_12_load_raw;
7177:     load_raw = &CLASS unpacked_load_raw;
7197:     load_raw = &CLASS fuji_load_raw;
7204:     load_raw = &CLASS minolta_rd175_load_raw;
7213:     load_raw = &CLASS unpacked_load_raw;
7218:       load_raw = &CLASS packed_12_load_raw;
7224:       load_raw = &CLASS packed_12_load_raw;
7241:       load_raw = &CLASS unpacked_load_raw;
7253:       load_raw = &CLASS eight_bit_load_raw;
7262:       load_raw = &CLASS packed_12_load_raw;
7271:     load_raw = &CLASS packed_12_load_raw;
7278:     load_raw = &CLASS packed_12_load_raw;
7285:     load_raw = &CLASS unpacked_load_raw;
7290:     load_raw = &CLASS eight_bit_load_raw;
7301:     load_raw = &CLASS unpacked_load_raw;
7309:     load_raw = &CLASS unpacked_load_raw;
7315:     load_raw = &CLASS eight_bit_load_raw;
7319:     load_raw = &CLASS eight_bit_load_raw;
7323:     load_raw = &CLASS eight_bit_load_raw;
7328: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7333:     load_raw = &CLASS unpacked_load_raw;
7342: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7350:     load_raw = &CLASS unpacked_load_raw;
7356: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7362:     load_raw = &CLASS unpacked_load_raw;
7375:     if (load_raw == &CLASS lossless_jpeg_load_raw)
7376:       load_raw = &CLASS hasselblad_load_raw;
7397:     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
7406:       load_raw = &CLASS leaf_hdr_load_raw;
7442:       load_raw = &CLASS panasonic_load_raw;
7443:     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
7538:     load_raw = &CLASS packed_12_load_raw;
7543:     if (load_raw == &CLASS olympus_e410_load_raw) {
7551:       if (load_raw == &CLASS unpacked_load_raw) {
7557:       if (load_raw == &CLASS unpacked_load_raw)
7569:     load_raw = &CLASS packed_12_load_raw;
7574:     load_raw = &CLASS sony_load_raw;
7582:     load_raw = &CLASS sony_load_raw;
7600:     load_raw = &CLASS kodak_yrgb_load_raw;
7618:     load_raw = &CLASS eight_bit_load_raw;
7671:       load_raw = &CLASS eight_bit_load_raw;
7677:       load_raw = &CLASS kodak_radc_load_raw;
7683:       load_raw = &CLASS kodak_radc_load_raw;
7690: 	&CLASS kodak_jpeg_load_raw : &CLASS kodak_dc120_load_raw;
7696:       write_thumb = &CLASS layer_thumb;
7700:       load_raw = &CLASS eight_bit_load_raw;
7707:     load_raw = &CLASS kodak_radc_load_raw;
7720:     load_raw = &CLASS quicktake_100_load_raw;
7725:     load_raw = &CLASS kodak_radc_load_raw;
7744:     load_raw = &CLASS rollei_load_raw;
7751:     load_raw = &CLASS eight_bit_load_raw;
7758:     load_raw = &CLASS eight_bit_load_raw;
7763:     load_raw = &CLASS eight_bit_load_raw;
7767:     load_raw = &CLASS unpacked_load_raw;
7772:     load_raw = &CLASS casio_qv5700_load_raw;
7836:   if (load_raw == &CLASS kodak_jpeg_load_raw) {
7858: void CLASS apply_profile (char *input, char *output)
7908: void CLASS convert_to_rgb()
8026: void CLASS fuji_rotate()
8064: void CLASS stretch()
8101: int CLASS flip_index (int row, int col)
8109: void CLASS gamma_lut (uchar lut[0x10000])
8154: void CLASS tiff_set (ushort *ntag,
8173: void CLASS tiff_head (struct tiff_hdr *th, int full)
8247: void CLASS jpeg_thumb (FILE *tfp)
8269: void CLASS write_ppm_tiff (FILE *ofp)
8311: int CLASS main (int argc, char **argv)
8496:     write_fun = &CLASS write_ppm_tiff;
8513:     if (load_raw == &CLASS kodak_ycbcr_load_raw) {
8638:     if (write_fun == &CLASS jpeg_thumb)
8640:     else if (output_tiff && write_fun == &CLASS write_ppm_tiff)
246:   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
chromium.googlesource.com/chromium/deps/xulrunner-sdk:win/bin/modules/Microformats.js: [ master, ]
1237:     "class" : {
71:         var altClass = Microformats.getElementsByClassName(rootElement, Microformats[name].alternateClassName);
1098:     var classValue = node.getAttribute("class");
1155:   className: "adr",
1221:   className: "vcard",
1433:   className: "vevent",
1641:   className: "geo",
31:     function isAncestor(haystack, needle) {
32:       var parent = needle;
36:         if (parent == needle.parentNode) {
186:         xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[mfname].className + " ')";
692:       /* is a class based microformat and the passed in node is not the */
708:       /* Query the correct set of nodes (rel or class) based on the setting */
734:             xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[Microformats.list[j]].className + " ')";
778:         /* If we didn't find any class nodes, check to see if this property */
791:      * the innerHTML and the class name.
1038:       xpathExpression = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1179:                                               "contains(concat(' ', @class, ' '), ' post-office-box ')" +
1180:                                               " or contains(concat(' ', @class, ' '), ' street-address ')" +
1181:                                               " or contains(concat(' ', @class, ' '), ' extended-address ')" +
1182:                                               " or contains(concat(' ', @class, ' '), ' locality ')" +
1183:                                               " or contains(concat(' ', @class, ' '), ' region ')" +
1184:                                               " or contains(concat(' ', @class, ' '), ' postal-code ')" +
1185:                                               " or contains(concat(' ', @class, ' '), ' country-name')" +
1442:     "class" : {
1614:     var xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vcard ')]";
1623:     xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vevent ')]";
65:     if (Microformats[name].className) {
67:                                         Microformats[name].className);
72:         if (altClass.length > 0) {
148:       if (Microformats[i].className) {
149:         if (Microformats.matchClass(node, Microformats[i].className)) {
185:       if (Microformats[mfname].className) {
220:         if (Microformats[i].className) {
221:           if (Microformats.matchClass(node, Microformats[i].className)) {
348:         if (!Microformats.matchClass(propnode, "value")) {
434:       if (Microformats.matchClass(propnode, "value")) {
464:         if (Microformats.matchClass(propnode, "value")) {
599:           if (!Microformats.matchClass(in_node, Microformats[microformat].className)) {
605:       if ((Microformats[microformat].className) && in_node.ownerDocument) {
696:       if (!in_mfnode.origNode && Microformats[mfname].className && in_mfnode.ownerDocument) {
728:           if (Microformats[Microformats.list[j]].className) {
826:               tempNode.className = headerNode.className;
1017:    * Retrieve elements matching all classes listed in a space-separated string.
1021:    * @param  className        A space separated list of classenames
1025:   getElementsByClassName: function getElementsByClassName(rootNode, className)
1031:       var col = rootNode.getElementsByClassName(className);
1047:       className = className.replace(/\-/g, "\\-");
1050:         if (elements[i].className.match("(^|\\s)" + className + "(\\s|$)")) {
1097:   matchClass: function matchClass(node, className) {
1099:     return (classValue && classValue.match("(^|\\s)" + className + "(\\s|$)"));
1720:           var ioService = Components.classes["@mozilla.org/network/io-service;1"].
66:       microformatNodes = Microformats.getElementsByClassName(rootElement,
68:       /* alternateClassName is for cases where a parent microformat is inferred by the children */
69:       /* If we find alternateClassName, the entire document becomes the microformat */
70:       if ((microformatNodes.length == 0) && Microformats[name].alternateClassName) {
323:         var values = Microformats.getElementsByClassName(propnode, "value");
640:             subpropnodes = Microformats.getElementsByClassName(propnode, subpropname);
714:         propnodes = Microformats.getElementsByClassName(mfnode, propname);
800:       var includes = Microformats.getElementsByClassName(in_mfnode, "include");
805:           includes = Microformats.getElementsByClassName(mfnode, "include");
1029:     if ((rootNode.ownerDocument || rootNode).getElementsByClassName) {
1030:     /* Firefox 3 - native getElementsByClassName */
1207:     var fns = Microformats.getElementsByClassName(this.node, "fn");
1416:     var summaries = Microformats.getElementsByClassName(this.node, "summary");
github.com/google/myanmar-tools:clients/js/package-lock.json: [ master, ]
1881:             "needle": "^2.2.1",
402:         "class-utils": "^0.3.5",
1183:         "posix-character-classes": "^0.1.0",
616:     "class-utils": {
618:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1860:         "needle": {
1862:           "resolved": "https://registry.npmjs.org/needle/-/needle-2.3.0.tgz",
3930:     "posix-character-classes": {
3932:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/bazelbuild/rules_nodejs:tools/fine_grained_deps_npm/package-lock.json: [ master, ]
768:             "needle": "^2.2.0",
97:         "class-utils": "^0.3.5",
348:         "posix-character-classes": "^0.1.0",
219:     "class-utils": {
221:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
751:         "needle": {
1521:     "posix-character-classes": {
1523:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/llvm-mirror/llvm:utils/TableGen/SearchableTableEmitter.cpp: [ master, ]
47:   Record *Class;
88: class SearchableTableEmitter {
532:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
655:     Enum->Class = Records.getClass(FilterClass);
656:     if (!Enum->Class)
723:     Record *Class = NameRec.second.get();
724:     if (Class->getSuperClasses().size() != 1 ||
725:         !Class->isSubClassOf(SearchableTable))
728:     StringRef TableName = Class->getName();
730:     if (!Class->isValueUnset("EnumNameField")) {
731:       StringRef NameField = Class->getValueAsString("EnumNameField");
733:       if (!Class->isValueUnset("EnumValueField"))
734:         ValueField = Class->getValueAsString("EnumValueField");
737:       Enum->Name = (Twine(Class->getName()) + "Values").str();
738:       Enum->PreprocessorGuard = Class->getName().upper();
739:       Enum->Class = Class;
747:     Table->Name = (Twine(Class->getName()) + "sList").str();
748:     Table->PreprocessorGuard = Class->getName().upper();
749:     Table->CppTypeName = Class->getName();
751:     for (const RecordVal &Field : Class->getValues()) {
767:          Class->getValueAsListOfStrings("SearchableFields")) {
623:   Record *IntrinsicClass = Records.getClass("Intrinsic");
624:   Record *InstructionClass = Records.getClass("Instruction");
627:       if (IntrinsicClass && RecordTy->isSubClassOf(IntrinsicClass))
629:       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
636:   // Emit tables in a deterministic order to avoid needless rebuilds.
654:     StringRef FilterClass = EnumRec->getValueAsString("FilterClass");
657:       PrintFatalError(EnumRec->getLoc(), Twine("Enum FilterClass '") +
658:                                              FilterClass + "' does not exist");
661:                        Records.getAllDerivedDefinitions(FilterClass));
687:                                     TableRec->getValueAsString("FilterClass")));
721:   Record *SearchableTable = Records.getClass("SearchableTable");
130:       return DI->getDef()->isSubClassOf("Intrinsic");
530:     if (TypeRec->isSubClassOf("GenericEnum")) {
722:   for (auto &NameRec : Records.getClasses()) {
github.com/googlearchive/caja:third_party/js/sunspider-benchmark/parse-only/prototype-1.6.0.3.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/native_client/nacl-llvm-project-v10:llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ]
47:   Record *Class = nullptr;
88: class SearchableTableEmitter {
532:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
655:     Enum->Class = Records.getClass(FilterClass);
656:     if (!Enum->Class)
723:     Record *Class = NameRec.second.get();
724:     if (Class->getSuperClasses().size() != 1 ||
725:         !Class->isSubClassOf(SearchableTable))
728:     StringRef TableName = Class->getName();
730:     if (!Class->isValueUnset("EnumNameField")) {
731:       StringRef NameField = Class->getValueAsString("EnumNameField");
733:       if (!Class->isValueUnset("EnumValueField"))
734:         ValueField = Class->getValueAsString("EnumValueField");
737:       Enum->Name = (Twine(Class->getName()) + "Values").str();
738:       Enum->PreprocessorGuard = Class->getName().upper();
739:       Enum->Class = Class;
747:     Table->Name = (Twine(Class->getName()) + "sList").str();
748:     Table->PreprocessorGuard = Class->getName().upper();
749:     Table->CppTypeName = Class->getName();
751:     for (const RecordVal &Field : Class->getValues()) {
767:          Class->getValueAsListOfStrings("SearchableFields")) {
623:   Record *IntrinsicClass = Records.getClass("Intrinsic");
624:   Record *InstructionClass = Records.getClass("Instruction");
627:       if (IntrinsicClass && RecordTy->isSubClassOf(IntrinsicClass))
629:       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
636:   // Emit tables in a deterministic order to avoid needless rebuilds.
654:     StringRef FilterClass = EnumRec->getValueAsString("FilterClass");
657:       PrintFatalError(EnumRec->getLoc(), Twine("Enum FilterClass '") +
658:                                              FilterClass + "' does not exist");
661:                        Records.getAllDerivedDefinitions(FilterClass));
687:                                     TableRec->getValueAsString("FilterClass")));
721:   Record *SearchableTable = Records.getClass("SearchableTable");
130:       return DI->getDef()->isSubClassOf("Intrinsic");
530:     if (TypeRec->isSubClassOf("GenericEnum")) {
722:   for (auto &NameRec : Records.getClasses()) {
github.com/googlei18n/myanmar-tools:clients/js/package-lock.json: [ master, ] Duplicate result
github.com/googlecreativelab/mystery-animal:functions/modules/data/animal_names_sizes.json: [ master, ]
6:       "class": "Mammalia",
12:       "class": "Aves",
19:       "class": "Aves",
26:       "class": "Aves",
33:       "class": "Aves",
40:       "class": "Aves",
47:       "class": "Mammalia",
54:       "class": "Gastropoda",
61:       "class": "Mammalia",
68:       "class": "Mammalia",
75:       "class": "Mammalia",
82:       "class": "Aves",
89:       "class": "Aves",
96:       "class": "Reptilia",
103:       "class": "Aves",
110:       "class": "Aves",
117:       "class": "Mammalia",
124:       "class": "Aves",
131:       "class": "Aves",
138:       "class": "Aves",
145:       "class": "Aves",
152:       "class": "Aves",
159:       "class": "Aves",
166:       "class": "Chondrichthyes",
173:       "class": "Aves",
180:       "class": "Aves",
187:       "class": "Aves",
194:       "class": "Aves",
201:       "class": "Aves",
208:       "class": "Aves",
215:       "class": "Reptilia",
222:       "class": "Aves",
229:       "class": "Mammalia",
236:       "class": "Mammalia",
243:       "class": "Mammalia",
250:       "class": "Aves",
257:       "class": "Aves",
264:       "class": "Aves",
271:       "class": "Mammalia",
278:       "class": "Mammalia",
285:       "class": "Mammalia",
292:       "class": "Aves",
299:       "class": "Actinopterygii",
306:       "class": "Aves",
313:       "class": "Mammalia",
320:       "class": "Mammalia",
327:       "class": "Actinopterygii",
334:       "class": "Mammalia",
341:       "class": "Mammalia",
348:       "class": "Aves",
355:       "class": "Reptilia",
362:       "class": "Mammalia",
369:       "class": "Chondrichthyes",
376:       "class": "Aves",
383:       "class": "Actinopterygii",
390:       "class": "Actinopterygii",
397:       "class": "Actinopterygii",
404:       "class": "Mammalia",
411:       "class": "Mammalia",
418:       "class": "Mammalia",
425:       "class": "Aves",
432:       "class": "Aves",
439:       "class": "Aves",
446:       "class": "Aves",
453:       "class": "Aves",
460:       "class": "Aves",
467:       "class": "Actinopterygii",
474:       "class": "Aves",
481:       "class": "Mammalia",
488:       "class": "Amphibia",
495:       "class": "Amphibia",
502:       "class": "Actinopterygii",
509:       "class": "Actinopterygii",
516:       "class": "Actinopterygii",
523:       "class": "Reptilia",
530:       "class": "Actinopterygii",
537:       "class": "Mammalia",
544:       "class": "Aves",
551:       "class": "Aves",
558:       "class": "Aves",
565:       "class": "Mammalia",
572:       "class": "Mammalia",
579:       "class": "Mammalia",
586:       "class": "Mammalia",
593:       "class": "Mammalia",
600:       "class": "Actinopterygii",
607:       "class": "Aves",
614:       "class": "Reptilia",
621:       "class": "Aves",
628:       "class": "Aves",
635:       "class": "Aves",
642:       "class": "Aves",
649:       "class": "Aves",
656:       "class": "Aves",
663:       "class": "Aves",
670:       "class": "Aves",
677:       "class": "Aves",
684:       "class": "Aves",
691:       "class": "Aves",
698:       "class": "Amphibia",
705:       "class": "Aves",
712:       "class": "Amphibia",
719:       "class": "Arachnida",
726:       "class": "Actinopterygii",
733:       "class": "Aves",
740:       "class": "Reptilia",
747:       "class": "Aves",
754:       "class": "Reptilia",
761:       "class": "Mammalia",
768:       "class": "Mammalia",
775:       "class": "Aves",
782:       "class": "Aves",
789:       "class": "Aves",
796:       "class": "Aves",
803:       "class": "Aves",
810:       "class": "Aves",
817:       "class": "Aves",
824:       "class": "Aves",
831:       "class": "Aves",
838:       "class": "Reptilia",
845:       "class": "Mammalia",
852:       "class": "Aves",
859:       "class": "Aves",
866:       "class": "Aves",
873:       "class": "Mammalia",
880:       "class": "Mammalia",
887:       "class": "Mammalia",
894:       "class": "Mammalia",
901:       "class": "Mammalia",
908:       "class": "Mammalia",
915:       "class": "Mammalia",
922:       "class": "Reptilia",
929:       "class": "Aves",
936:       "class": "Aves",
943:       "class": "Actinopterygii",
950:       "class": "Gastropoda",
957:       "class": "Aves",
964:       "class": "Aves",
971:       "class": "Aves",
978:       "class": "Aves",
985:       "class": "Aves",
992:       "class": "Aves",
999:       "class": "Aves",
1006:       "class": "Aves",
1013:       "class": "Aves",
1020:       "class": "Aves",
1027:       "class": "Aves",
1034:       "class": "Aves",
1041:       "class": "Aves",
1048:       "class": "Aves",
1055:       "class": "Aves",
1062:       "class": "Arachnida",
1069:       "class": "Actinopterygii",
1076:       "class": "Aves",
1083:       "class": "Aves",
1090:       "class": "Aves",
1097:       "class": "Mammalia",
1104:       "class": "Aves",
1111:       "class": "Mammalia",
1118:       "class": "Mammalia",
1125:       "class": "Mammalia",
1132:       "class": "Mammalia",
1139:       "class": "Mammalia",
1146:       "class": "Mammalia",
1153:       "class": "Mammalia",
1160:       "class": "Mammalia",
1167:       "class": "Mammalia",
1174:       "class": "Mammalia",
1181:       "class": "Aves",
1188:       "class": "Aves",
1195:       "class": "Aves",
1202:       "class": "Aves",
1209:       "class": "Aves",
1216:       "class": "Aves",
1223:       "class": "Gastropoda",
1230:       "class": "Malacostraca",
1237:       "class": "Mammalia",
1244:       "class": "Mammalia",
1251:       "class": "Mammalia",
1258:       "class": "Mammalia",
1265:       "class": "Aves",
1272:       "class": "Aves",
1279:       "class": "Reptilia",
1286:       "class": "Malacostraca",
1293:       "class": "Reptilia",
1300:       "class": "Aves",
1307:       "class": "Mammalia",